Full Code of beet-aizu/library for AI

gitextract_cqk4qi75/

├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   └── feature_request.md
│   └── workflows/
│       ├── sanitize.yml
│       └── verify.yml
├── .gitignore
├── .gitignore_gen.sh
├── .verify-helper/
│   ├── config.toml
│   ├── docs/
│   │   └── _config.yml
│   ├── local.toml
│   ├── sanitize.toml
│   ├── timestamps.local.json.20201106
│   ├── timestamps.local.json.20210324
│   └── timestamps.remote.json
├── README.md
├── algorithm/
│   ├── knuthyao.cpp
│   ├── largestrectangle.cpp
│   ├── mo.cpp
│   ├── monotoneminima.cpp
│   ├── offlineonline.cpp
│   ├── optimalbinarytree.cpp
│   ├── parallelbinarysearch.cpp
│   └── partialsum.cpp
├── bbst/
│   ├── pb_ds_tree.cpp
│   └── rbst/
│       ├── data/
│       │   ├── array.cpp
│       │   ├── dual.cpp
│       │   ├── lazy.cpp
│       │   └── ushi.cpp
│       ├── impl/
│       │   ├── basic.cpp
│       │   └── persistent.cpp
│       └── rbst.cpp
├── bflow/
│   └── capacityscaling.cpp
├── clean.sh
├── combinatorics/
│   ├── bell.cpp
│   ├── bernoulli.cpp
│   ├── enumeration.cpp
│   ├── partition.cpp
│   ├── partitiontable.cpp
│   ├── stirling1st.cpp
│   ├── stirling2nd.cpp
│   └── surjection.cpp
├── convexhulltrick/
│   ├── convexhulltrick.cpp
│   ├── linecontainer.cpp
│   ├── segmentcontainer.cpp
│   └── withindex.cpp
├── convolution/
│   ├── arbitrarymod.cpp
│   ├── bitwise/
│   │   ├── and.cpp
│   │   ├── fwht.cpp
│   │   ├── or.cpp
│   │   └── xor.cpp
│   ├── convolution2D.cpp
│   ├── divisor.cpp
│   ├── fastfouriertransform.cpp
│   ├── garner.cpp
│   ├── naive.cpp
│   └── numbertheoretictransform.cpp
├── datastructure/
│   ├── BIT2D.cpp
│   ├── absolutesum.cpp
│   ├── binaryindexedtree.cpp
│   ├── binarytrie.cpp
│   ├── bitvector.cpp
│   ├── cartesiantree.cpp
│   ├── cumulativesum.cpp
│   ├── disjointsparsetable.cpp
│   ├── kdtree.cpp
│   ├── pb_ds_cc_hash_table.cpp
│   ├── prioritysum.cpp
│   ├── quickfind.cpp
│   ├── radixheap.cpp
│   ├── rangeslide.cpp
│   ├── rotcev.cpp
│   ├── skewheap.cpp
│   ├── slidingwindowaggregation.cpp
│   ├── slope.cpp
│   ├── sparsetable.cpp
│   ├── unionfind.cpp
│   ├── waveletmatrix.cpp
│   └── weightedunionfind.cpp
├── docs/
│   ├── bflow/
│   │   └── capacityscaling.md
│   ├── datastructure/
│   │   ├── binaryindexedtree.md
│   │   └── waveletmatrix.md
│   ├── graph/
│   │   └── rangetorange.md
│   ├── maxflow/
│   │   ├── dinic.md
│   │   ├── fordfulkerson.md
│   │   ├── leastflow.md
│   │   └── twocommodity.md
│   ├── mincostflow/
│   │   ├── negativeedge.md
│   │   └── primaldual.md
│   ├── segtree/
│   │   └── basic/
│   │       └── lazy.md
│   ├── string/
│   │   ├── longestcommonprefix.md
│   │   └── suffixarray.md
│   ├── test/
│   │   ├── aoj/
│   │   │   ├── 0438.test.md
│   │   │   ├── 0563.test.md
│   │   │   ├── 1549.test.md
│   │   │   ├── 1595.toptree.test.md
│   │   │   ├── 2290.test.md
│   │   │   ├── 2313.test.md
│   │   │   ├── 2636.test.md
│   │   │   ├── 2667.test.md
│   │   │   ├── 2679.test.md
│   │   │   ├── 2711.test.md
│   │   │   ├── 2725.linecontainer.test.md
│   │   │   ├── 2890.test.md
│   │   │   ├── 3069.test.md
│   │   │   ├── 3112.test.md
│   │   │   ├── 3117.test.md
│   │   │   ├── 3143.test.md
│   │   │   ├── DSL_2_F.test.md
│   │   │   ├── DSL_2_H.test.md
│   │   │   └── DSL_2_I.test.md
│   │   ├── yosupo/
│   │   │   └── range_kth_smallest.test.md
│   │   └── yukicoder/
│   │       ├── 1732.test.md
│   │       ├── 1937.test.md
│   │       ├── 3267.test.md
│   │       ├── 3453.test.md
│   │       └── 7107.test.md
│   ├── toptree/
│   │   └── toptree.md
│   └── tree/
│       ├── ahu.md
│       ├── auxiliarytree.md
│       ├── heavylightdecomposition.md
│       ├── rerooting.md
│       └── sack.md
├── formalpowerseries/
│   ├── 998244353.cpp
│   ├── base.cpp
│   ├── diff.cpp
│   ├── div.cpp
│   ├── exp.cpp
│   ├── integral.cpp
│   ├── inv.cpp
│   ├── log.cpp
│   ├── mod.cpp
│   ├── pow.cpp
│   ├── shift.cpp
│   └── sqrt.cpp
├── geometry/
│   ├── 3D/
│   │   └── geometry3D.cpp
│   ├── argsort.cpp
│   ├── geometry.cpp
│   └── projectilemotion.cpp
├── graph/
│   ├── arborescence_edmond.cpp
│   ├── arborescence_tarjan.cpp
│   ├── bellmanford.cpp
│   ├── bfs.cpp
│   ├── bipartitedecomposition.cpp
│   ├── chromatic.cpp
│   ├── cycle.cpp
│   ├── dijkstra.cpp
│   ├── dominatortree.cpp
│   ├── dynamicconnectivity.cpp
│   ├── girth.cpp
│   ├── grid.cpp
│   ├── independentset.cpp
│   ├── kruskal.cpp
│   ├── lowlink.cpp
│   ├── manhattanmst.cpp
│   ├── multipleeuleriantrail.cpp
│   ├── nicetree.cpp
│   ├── rangetorange.cpp
│   ├── semikernel.cpp
│   ├── stronglyconnectedcomponent.cpp
│   ├── topologicalsort.cpp
│   ├── triangle.cpp
│   ├── twoedgeconnectedcomponents.cpp
│   ├── twosatisfiability.cpp
│   └── voronoiminimumspanningtree.cpp
├── heuristic/
│   ├── timer.cpp
│   └── xorshift.cpp
├── includes/
│   └── formalpowerseries.h
├── io/
│   ├── precision.cpp
│   ├── single.cpp
│   ├── space.cpp
│   ├── tuple.cpp
│   └── yesno.cpp
├── leetcode/
│   └── treenode.cpp
├── linearalgebra/
│   ├── binarymatrix.cpp
│   ├── matrix.cpp
│   ├── squarematrix.cpp
│   └── tree_theorem.cpp
├── linkcuttree/
│   ├── base.cpp
│   ├── farthest.cpp
│   ├── path.cpp
│   └── subtree.cpp
├── matching/
│   ├── bipartite.cpp
│   ├── hopcroft_karp.cpp
│   └── tutte.cpp
├── math/
│   ├── affine.cpp
│   ├── bostanmori.cpp
│   ├── carmichael.cpp
│   ├── combination.cpp
│   ├── convertbase.cpp
│   ├── dual.cpp
│   ├── enumerate_primes.cpp
│   ├── extgcd.cpp
│   ├── factorize.cpp
│   ├── fraction.cpp
│   ├── isprime.cpp
│   ├── kitamasa.cpp
│   ├── linearcongruence.cpp
│   ├── linearfunction.cpp
│   ├── moebius.cpp
│   ├── quotients.cpp
│   ├── sum_of_floor.cpp
│   ├── sum_of_geometric_sequence.cpp
│   ├── tetrahedra.cpp
│   ├── totient.cpp
│   ├── totient_table.cpp
│   └── twoway.cpp
├── maxflow/
│   ├── dinic.cpp
│   ├── fordfulkerson.cpp
│   ├── leastflow.cpp
│   └── twocommodity.cpp
├── mincostflow/
│   ├── negativeedge.cpp
│   └── primaldual.cpp
├── mod/
│   ├── factorial.cpp
│   ├── inverse.cpp
│   ├── log.cpp
│   ├── mint.cpp
│   ├── montmort.cpp
│   ├── order.cpp
│   ├── pow.cpp
│   ├── rint.cpp
│   ├── sqrt.cpp
│   └── tetration.cpp
├── polynomial/
│   ├── berlekampmassey.cpp
│   ├── hash.cpp
│   ├── interpolate.cpp
│   ├── lagrangeinterpolation.cpp
│   ├── multieval.cpp
│   ├── polynomial.cpp
│   └── recursivesequence.cpp
├── segtree/
│   ├── 2d/
│   │   └── ushi.cpp
│   ├── basic/
│   │   ├── dual.cpp
│   │   ├── lazy.cpp
│   │   └── ushi.cpp
│   ├── count/
│   │   ├── dynamic_offline.cpp
│   │   └── static.cpp
│   ├── persistent/
│   │   └── ushi.cpp
│   └── types/
│       ├── offline.cpp
│       └── online.cpp
├── string/
│   ├── ahocorasick.cpp
│   ├── editdistance.cpp
│   ├── knuthmorrispratt.cpp
│   ├── longestcommonprefix.cpp
│   ├── longestcommonsubstring.cpp
│   ├── manacher.cpp
│   ├── morrispratt.cpp
│   ├── palindromictree.cpp
│   ├── parse.cpp
│   ├── rectanglehash.cpp
│   ├── rollinghash.cpp
│   ├── run.cpp
│   ├── split.cpp
│   ├── suffixarray.cpp
│   ├── trie.cpp
│   └── zalgorithm.cpp
├── test/
│   ├── aoj/
│   │   ├── 0109.test.cpp
│   │   ├── 0168.test.cpp
│   │   ├── 0233.test.cpp
│   │   ├── 0294.test.cpp
│   │   ├── 0314.test.cpp
│   │   ├── 0343.test.cpp
│   │   ├── 0367.linkcuttree.test.cpp
│   │   ├── 0367.test.cpp
│   │   ├── 0367.toptree.test.cpp
│   │   ├── 0377.test.cpp
│   │   ├── 0391.test.cpp
│   │   ├── 0402.test.cpp
│   │   ├── 0403.test.cpp
│   │   ├── 0415.test.cpp
│   │   ├── 0422.test.cpp
│   │   ├── 0423.test.cpp
│   │   ├── 0424.test.cpp
│   │   ├── 0425.test.cpp
│   │   ├── 0437.test.cpp
│   │   ├── 0438.test.cpp
│   │   ├── 0439.test.cpp
│   │   ├── 0502.test.cpp
│   │   ├── 0558.test.cpp
│   │   ├── 0563.test.cpp
│   │   ├── 0596.test.cpp
│   │   ├── 0613.test.cpp
│   │   ├── 1069.test.cpp
│   │   ├── 1197.test.cpp
│   │   ├── 1254.test.cpp
│   │   ├── 1293.test.cpp
│   │   ├── 1300.test.cpp
│   │   ├── 1308.test.cpp
│   │   ├── 1312.test.cpp
│   │   ├── 1328.test.cpp
│   │   ├── 1338.test.cpp
│   │   ├── 1508.test.cpp
│   │   ├── 1549.test.cpp
│   │   ├── 1579.test.cpp
│   │   ├── 1595.linkcuttree.test.cpp
│   │   ├── 1595.test.cpp
│   │   ├── 1595.toptree.test.cpp
│   │   ├── 1599.test.cpp
│   │   ├── 1607.test.cpp
│   │   ├── 1613.test.cpp
│   │   ├── 1615.test.cpp
│   │   ├── 1630.test.cpp
│   │   ├── 1642.test.cpp
│   │   ├── 2060.test.cpp
│   │   ├── 2187.test.cpp
│   │   ├── 2212.test.cpp
│   │   ├── 2222.test.cpp
│   │   ├── 2230.test.cpp
│   │   ├── 2235.test.cpp
│   │   ├── 2257.test.cpp
│   │   ├── 2270.test.cpp
│   │   ├── 2286.test.cpp
│   │   ├── 2290.test.cpp
│   │   ├── 2292.test.cpp
│   │   ├── 2294.test.cpp
│   │   ├── 2308.test.cpp
│   │   ├── 2309.tarjan.test.cpp
│   │   ├── 2309.test.cpp
│   │   ├── 2313.test.cpp
│   │   ├── 2324.test.cpp
│   │   ├── 2328.test.cpp
│   │   ├── 2359.test.cpp
│   │   ├── 2370.test.cpp
│   │   ├── 2397.test.cpp
│   │   ├── 2405.test.cpp
│   │   ├── 2415.knuthyao.test.cpp
│   │   ├── 2415.test.cpp
│   │   ├── 2432.ignore.cpp
│   │   ├── 2444.test.cpp
│   │   ├── 2446.test.cpp
│   │   ├── 2450.linkcuttree.test.cpp
│   │   ├── 2450.test.cpp
│   │   ├── 2488.test.cpp
│   │   ├── 2513.test.cpp
│   │   ├── 2560.test.cpp
│   │   ├── 2563.test.cpp
│   │   ├── 2603.test.cpp
│   │   ├── 2624.test.cpp
│   │   ├── 2627.test.cpp
│   │   ├── 2636.test.cpp
│   │   ├── 2644.test.cpp
│   │   ├── 2646.test.cpp
│   │   ├── 2647.test.cpp
│   │   ├── 2659.test.cpp
│   │   ├── 2667.test.cpp
│   │   ├── 2674.count.test.cpp
│   │   ├── 2674.test.cpp
│   │   ├── 2679.test.cpp
│   │   ├── 2687.test.cpp
│   │   ├── 2711.test.cpp
│   │   ├── 2720.test.cpp
│   │   ├── 2725.linecontainer.test.cpp
│   │   ├── 2725.test.cpp
│   │   ├── 2736.test.cpp
│   │   ├── 2790.test.cpp
│   │   ├── 2842.BIT2D.test.cpp
│   │   ├── 2842.test.cpp
│   │   ├── 2871.test.cpp
│   │   ├── 2872.test.cpp
│   │   ├── 2890.test.cpp
│   │   ├── 2891.test.cpp
│   │   ├── 2934.test.cpp
│   │   ├── 2948.test.cpp
│   │   ├── 2951.test.cpp
│   │   ├── 2959.test.cpp
│   │   ├── 2968.test.cpp
│   │   ├── 2969.test.cpp
│   │   ├── 2970.test.cpp
│   │   ├── 2971.test.cpp
│   │   ├── 2975.test.cpp
│   │   ├── 2977.test.cpp
│   │   ├── 2979.test.cpp
│   │   ├── 2981.test.cpp
│   │   ├── 2983.test.cpp
│   │   ├── 2985.garner.test.cpp
│   │   ├── 2985.test.cpp
│   │   ├── 2995.test.cpp
│   │   ├── 3024.test.cpp
│   │   ├── 3033.test.cpp
│   │   ├── 3035.test.cpp
│   │   ├── 3037.test.cpp
│   │   ├── 3047.test.cpp
│   │   ├── 3053.test.cpp
│   │   ├── 3058.test.cpp
│   │   ├── 3062.test.cpp
│   │   ├── 3063.test.cpp
│   │   ├── 3069.test.cpp
│   │   ├── 3072.test.cpp
│   │   ├── 3073.test.cpp
│   │   ├── 3074.test.cpp
│   │   ├── 3081.test.cpp
│   │   ├── 3084.test.cpp
│   │   ├── 3086.test.cpp
│   │   ├── 3102.test.cpp
│   │   ├── 3112.test.cpp
│   │   ├── 3117.test.cpp
│   │   ├── 3120.test.cpp
│   │   ├── 3138.test.cpp
│   │   ├── 3142.test.cpp
│   │   ├── 3143.test.cpp
│   │   ├── 3148.test.cpp
│   │   ├── 3168.test.cpp
│   │   ├── 3179.test.cpp
│   │   ├── 3183.test.cpp
│   │   ├── 3198.test.cpp
│   │   ├── 3208.test.cpp
│   │   ├── 3213.test.cpp
│   │   ├── 3506.test.cpp
│   │   ├── 3518.test.cpp
│   │   ├── ALDS1_10_C.test.cpp
│   │   ├── ALDS1_14_B.knuthmorrispratt.test.cpp
│   │   ├── ALDS1_14_B.test.cpp
│   │   ├── ALDS1_14_C.test.cpp
│   │   ├── ALDS1_15_B.test.cpp
│   │   ├── ALDS1_1_C.test.cpp
│   │   ├── ALDS1_5_D.test.cpp
│   │   ├── ALDS1_9_C.test.cpp
│   │   ├── DPL_1_E.test.cpp
│   │   ├── DPL_3_B.test.cpp
│   │   ├── DPL_3_C.test.cpp
│   │   ├── DPL_5_A.test.cpp
│   │   ├── DPL_5_B.test.cpp
│   │   ├── DPL_5_C.test.cpp
│   │   ├── DPL_5_D.test.cpp
│   │   ├── DPL_5_E.test.cpp
│   │   ├── DPL_5_F.test.cpp
│   │   ├── DPL_5_G.test.cpp
│   │   ├── DPL_5_H.test.cpp
│   │   ├── DPL_5_I.test.cpp
│   │   ├── DPL_5_J.test.cpp
│   │   ├── DPL_5_K.test.cpp
│   │   ├── DPL_5_L.test.cpp
│   │   ├── DSL_1_A.quickfind.test.cpp
│   │   ├── DSL_1_A.test.cpp
│   │   ├── DSL_1_B.test.cpp
│   │   ├── DSL_2_B.test.cpp
│   │   ├── DSL_2_C.test.cpp
│   │   ├── DSL_2_D.test.cpp
│   │   ├── DSL_2_E.test.cpp
│   │   ├── DSL_2_F.bbst.test.cpp
│   │   ├── DSL_2_F.test.cpp
│   │   ├── DSL_2_G.bbst.test.cpp
│   │   ├── DSL_2_H.bbst.test.cpp
│   │   ├── DSL_2_H.test.cpp
│   │   ├── DSL_2_I.bbst.test.cpp
│   │   ├── DSL_2_I.test.cpp
│   │   ├── DSL_3_D.cartesiantree.test.cpp
│   │   ├── DSL_3_D.disjointsparsetable.test.cpp
│   │   ├── DSL_3_D.slidingwindowaggregation.test.cpp
│   │   ├── DSL_3_D.sparsetable.test.cpp
│   │   ├── DSL_3_D.test.cpp
│   │   ├── GRL_1_A.test.cpp
│   │   ├── GRL_1_B.test.cpp
│   │   ├── GRL_2_A.test.cpp
│   │   ├── GRL_2_B.tarjan.test.cpp
│   │   ├── GRL_2_B.test.cpp
│   │   ├── GRL_3_A.test.cpp
│   │   ├── GRL_3_B.test.cpp
│   │   ├── GRL_4_B.ignore.cpp
│   │   ├── GRL_5_A.linkcuttree.test.cpp
│   │   ├── GRL_5_A.test.cpp
│   │   ├── GRL_5_C.lca.test.cpp
│   │   ├── GRL_5_C.test.cpp
│   │   ├── GRL_5_D.linkcuttree.test.cpp
│   │   ├── GRL_5_D.test.cpp
│   │   ├── GRL_5_E.linkcuttree.test.cpp
│   │   ├── GRL_6_A.test.cpp
│   │   ├── GRL_6_B.test.cpp
│   │   ├── GRL_7_A.test.cpp
│   │   ├── ITP1_11_A.test.cpp
│   │   ├── ITP1_11_B.test.cpp
│   │   ├── ITP1_11_C.test.cpp
│   │   ├── ITP1_11_D.test.cpp
│   │   ├── NTL_1_A.test.cpp
│   │   ├── NTL_1_B.test.cpp
│   │   ├── NTL_1_D.test.cpp
│   │   ├── NTL_1_E.test.cpp
│   │   ├── NTL_2_A.test.cpp
│   │   ├── NTL_2_B.test.cpp
│   │   ├── NTL_2_C.test.cpp
│   │   ├── NTL_2_D.test.cpp
│   │   ├── NTL_2_E.test.cpp
│   │   ├── NTL_2_F.test.cpp
│   │   └── geometry/
│   │       ├── 2334.test.cpp
│   │       ├── 2448.test.cpp
│   │       ├── 2454.test.cpp
│   │       ├── 3049.test.cpp
│   │       ├── 3056.test.cpp
│   │       ├── CGL_1_A.test.cpp
│   │       ├── CGL_1_B.test.cpp
│   │       ├── CGL_1_C.test.cpp
│   │       ├── CGL_2_A.test.cpp
│   │       ├── CGL_2_B.test.cpp
│   │       ├── CGL_2_C.test.cpp
│   │       ├── CGL_2_D.test.cpp
│   │       ├── CGL_3_A.test.cpp
│   │       ├── CGL_3_B.test.cpp
│   │       ├── CGL_3_C.test.cpp
│   │       ├── CGL_4_A.test.cpp
│   │       ├── CGL_4_B.test.cpp
│   │       ├── CGL_4_C.test.cpp
│   │       ├── CGL_5_A.test.cpp
│   │       ├── CGL_6_A.test.cpp
│   │       ├── CGL_7_A.test.cpp
│   │       ├── CGL_7_D.test.cpp
│   │       ├── CGL_7_E.test.cpp
│   │       ├── CGL_7_F.test.cpp
│   │       ├── CGL_7_G.test.cpp
│   │       ├── CGL_7_H.test.cpp
│   │       └── CGL_7_I.test.cpp
│   ├── yosupo/
│   │   ├── assignment.test.cpp
│   │   ├── associative_array.test.cpp
│   │   ├── bernoulli_number.test.cpp
│   │   ├── bipartitematching.test.cpp
│   │   ├── bitwise_and_convolution.test.cpp
│   │   ├── bitwise_xor_convolution.test.cpp
│   │   ├── cartesian_tree.test.cpp
│   │   ├── convolution_mod.test.cpp
│   │   ├── convolution_mod_1000000007.garner.test.cpp
│   │   ├── convolution_mod_1000000007.test.cpp
│   │   ├── cycle_detection.test.cpp
│   │   ├── discrete_logarithm_mod.test.cpp
│   │   ├── dominatortree.test.cpp
│   │   ├── dynamic_sequence_range_affine_range_sum.test.cpp
│   │   ├── dynamic_tree_vertex_add_path_sum.test.cpp
│   │   ├── dynamic_tree_vertex_add_subtree_sum.test.cpp
│   │   ├── dynamic_tree_vertex_add_subtree_sum.toptree.test.cpp
│   │   ├── dynamic_tree_vertex_set_path_composite.test.cpp
│   │   ├── dynamic_tree_vertex_set_path_composite.toptree.test.cpp
│   │   ├── enumerate_primes.test.cpp
│   │   ├── enumerate_triangles.test.cpp
│   │   ├── exp_of_formal_power_series.test.cpp
│   │   ├── find_linear_recurrence.test.cpp
│   │   ├── frequency_table_of_tree_distance.test.cpp
│   │   ├── inv_of_formal_power_series.test.cpp
│   │   ├── kth_root_integer.test.cpp
│   │   ├── kth_term_of_linearly_recurrent_sequence.test.cpp
│   │   ├── lca.linkcuttree.test.cpp
│   │   ├── lca.test.cpp
│   │   ├── line_add_get_min.test.cpp
│   │   ├── log_of_formal_power_series.test.cpp
│   │   ├── manhattanmst.test.cpp
│   │   ├── many_aplusb.test.cpp
│   │   ├── matrix_det.test.cpp
│   │   ├── maximum_independent_set.test.cpp
│   │   ├── min_cost_b_flow.test.cpp
│   │   ├── montmort_number_mod.test.cpp
│   │   ├── multipoint_evaluation.test.cpp
│   │   ├── number_of_substrings.test.cpp
│   │   ├── partition_function.test.cpp
│   │   ├── persistent_queue.test.cpp
│   │   ├── point_add_range_sum.test.cpp
│   │   ├── point_add_rectangle_sum.test.cpp
│   │   ├── point_set_range_composite.test.cpp
│   │   ├── polynomial_interpolation.test.cpp
│   │   ├── polynomial_taylor_shift.test.cpp
│   │   ├── pow_of_formal_power_series.test.cpp
│   │   ├── queue_operate_all_composite.test.cpp
│   │   ├── range_affine_range_sum.test.cpp
│   │   ├── range_kth_smallest.test.cpp
│   │   ├── rectangle_sum.test.cpp
│   │   ├── runenumerate.test.cpp
│   │   ├── scc.test.cpp
│   │   ├── segment_add_get_min.test.cpp
│   │   ├── set_xor_min.test.cpp
│   │   ├── sharp_p_subset_sum.test.cpp
│   │   ├── shortest_path.test.cpp
│   │   ├── sort_points_by_argument.test.cpp
│   │   ├── sqrt_mod.test.cpp
│   │   ├── sqrt_of_formal_power_series.test.cpp
│   │   ├── static_range_frequency.test.cpp
│   │   ├── static_range_inversions_query.test.cpp
│   │   ├── static_range_sum.test.cpp
│   │   ├── staticrmq.disjointsparsetable.test.cpp
│   │   ├── staticrmq.sparsetable.test.cpp
│   │   ├── stirling_number_of_the_first_kind.test.cpp
│   │   ├── stirling_number_of_the_second_kind.test.cpp
│   │   ├── subset_convolution.test.cpp
│   │   ├── suffixarray.test.cpp
│   │   ├── sum_of_floor_of_linear.test.cpp
│   │   ├── tetration_mod.test.cpp
│   │   ├── tree_decomposition_width_2.test.cpp
│   │   ├── tree_diameter.test.cpp
│   │   ├── two_edge_connected_components.test.cpp
│   │   ├── two_sat.test.cpp
│   │   ├── unionfind.test.cpp
│   │   ├── vertex_add_path_sum.test.cpp
│   │   ├── vertex_add_subtree_sum.test.cpp
│   │   └── zalgorithm.test.cpp
│   └── yukicoder/
│       ├── 0022.test.cpp
│       ├── 0104.test.cpp
│       ├── 0143.test.cpp
│       ├── 0206.test.cpp
│       ├── 0222.test.cpp
│       ├── 0399.test.cpp
│       ├── 0444.test.cpp
│       ├── 0472.test.cpp
│       ├── 0771.test.cpp
│       ├── 0831.test.cpp
│       ├── 1013.test.cpp
│       ├── 1504.test.cpp
│       ├── 1580.test.cpp
│       ├── 1665.test.cpp
│       ├── 1732.test.cpp
│       ├── 1923.test.cpp
│       ├── 1937.test.cpp
│       ├── 1948.test.cpp
│       ├── 1950.test.cpp
│       ├── 1973.test.cpp
│       ├── 2063.test.cpp
│       ├── 2085.test.cpp
│       ├── 2113.test.cpp
│       ├── 2125.test.cpp
│       ├── 2147.test.cpp
│       ├── 2520.test.cpp
│       ├── 2587.test.cpp
│       ├── 2600.test.cpp
│       ├── 2744.test.cpp
│       ├── 2772.test.cpp
│       ├── 3211.test.cpp
│       ├── 3227.test.cpp
│       ├── 3267.test.cpp
│       ├── 3277.test.cpp
│       ├── 3354.test.cpp
│       ├── 3405.test.cpp
│       ├── 3407.test.cpp
│       ├── 3453.test.cpp
│       ├── 3592.test.cpp
│       ├── 3912.test.cpp
│       ├── 3961.test.cpp
│       ├── 4072.test.cpp
│       ├── 4117.test.cpp
│       ├── 4271.avx2.test.cpp
│       ├── 4271.test.cpp
│       ├── 4387.test.cpp
│       ├── 4474.test.cpp
│       ├── 4569.test.cpp
│       ├── 4706.test.cpp
│       ├── 4778.test.cpp
│       ├── 4852.test.cpp
│       ├── 4862.test.cpp
│       ├── 4872.test.cpp
│       ├── 4918.test.cpp
│       ├── 4941.test.cpp
│       ├── 5011.test.cpp
│       ├── 5025.test.cpp
│       ├── 5061.test.cpp
│       ├── 5223.test.cpp
│       ├── 5633.test.cpp
│       ├── 6680.test.cpp
│       ├── 7107.test.cpp
│       └── 9158.test.cpp
├── tools/
│   ├── all_permutations.cpp
│   ├── avx2.cpp
│   ├── bigint.cpp
│   ├── cc_hash.cpp
│   ├── chminmax.cpp
│   ├── debug.cpp
│   ├── defaultdict.cpp
│   ├── dice.cpp
│   ├── drop.cpp
│   ├── fastio.cpp
│   ├── fixpoint.cpp
│   ├── gridbfs.cpp
│   ├── int128.cpp
│   ├── iskado.cpp
│   └── trio.cpp
├── toptree/
│   ├── base.cpp
│   ├── distancesum.cpp
│   ├── farthest.cpp
│   ├── steiner.cpp
│   └── toptree.cpp
├── tree/
│   ├── ahu.cpp
│   ├── auxiliarytree.cpp
│   ├── centroid.cpp
│   ├── construct_from_distances_to_farthest_vertex.cpp
│   ├── diameterforedge.cpp
│   ├── diameterforvertex.cpp
│   ├── eulertourforbfs.cpp
│   ├── eulertourforedge.cpp
│   ├── eulertourforvertex.cpp
│   ├── heavylightdecomposition.cpp
│   ├── lca.cpp
│   ├── levelancestor.cpp
│   ├── lowestcommonancestor.cpp
│   ├── mo_on_tree.cpp
│   ├── rerooting.cpp
│   └── sack.cpp
└── vector/
    ├── compress.cpp
    ├── fusion.cpp
    ├── identity.cpp
    ├── inversion.cpp
    ├── multi.cpp
    ├── near.cpp
    ├── powers.cpp
    ├── reversed.cpp
    ├── runlength.cpp
    ├── sorted.cpp
    └── zip.cpp

SYMBOL INDEX (2303 symbols across 636 files)

FILE: algorithm/knuthyao.cpp
  function T (line 8) | T KnuthYao(int n,F cost){
  function main (line 29) | signed main(){

FILE: algorithm/largestrectangle.cpp
  function T (line 7) | T largestrectangle(vector<T> &v){
  function main (line 31) | signed main(){

FILE: algorithm/mo.cpp
  type Mo (line 6) | struct Mo{
    method Mo (line 13) | Mo(int n,int width,F expandL,F expandR,F shrinkL,F shrinkR):
    method Mo (line 18) | Mo(int n,int width,F expand,F shrink):
    method add (line 21) | void add(int l,int r){
    method build (line 26) | void build(){
    method process (line 37) | int process(){
  function main (line 49) | signed main(){

FILE: algorithm/monotoneminima.cpp
  type MonotoneMinima (line 6) | namespace MonotoneMinima{
    function induce (line 8) | void induce(int l,int r,int a,int b,vector<int> &dp,F dist){
    function args (line 23) | vector<int> args(int n,int m,F dist){
  function main (line 31) | signed main(){

FILE: algorithm/offlineonline.cpp
  type OfflineOnline (line 8) | namespace OfflineOnline{
    function update (line 12) | void update(vector<T> &dp,int k,T val){
    function induce (line 20) | void induce(int l,int r,int a,int b,vector<T> &dp,F dist){
    function solve (line 36) | void solve(int l,int r,vector<T> &dp,F dist){
    function T (line 46) | T solve(int n,F dist){
  function main (line 57) | signed main(){

FILE: algorithm/optimalbinarytree.cpp
  function T (line 12) | T optimalbinarytree(vector<T> ws){
  function main (line 88) | signed main(){

FILE: algorithm/parallelbinarysearch.cpp
  function parallel_binary_search (line 7) | vector<int> parallel_binary_search(int n,int q,
  function main (line 33) | signed main(){

FILE: algorithm/partialsum.cpp
  function partial_sum (line 9) | bitset<N+1> partial_sum(vector<int> vs){
  function main (line 30) | signed main(){

FILE: bbst/pb_ds_tree.cpp
  function main (line 19) | signed main(){

FILE: bbst/rbst/data/array.cpp
  type Array (line 7) | struct Array{
    type Node (line 8) | struct Node{
      method Node (line 13) | Node(T val):
    method count (line 17) | static inline size_t count(const Node *t){
    method toggle (line 21) | inline void toggle(Node *t){
    method dirty (line 26) | inline bool dirty(Node *t){
    method Node (line 30) | inline Node* eval(Node* t){
      method Node (line 13) | Node(T val):
    method Node (line 39) | inline Node* pushup(Node *t){
      method Node (line 13) | Node(T val):
    method T (line 44) | inline T get_val(Node *t){
    method dump (line 49) | void dump(typename vector<Node>::iterator it,Node* const t,bool rev){
    method dump (line 61) | vector<Node> dump(Node* t){
  function main (line 71) | signed main(){

FILE: bbst/rbst/data/dual.cpp
  type Dual (line 7) | struct Dual{
    type Node (line 8) | struct Node{
      method Node (line 13) | Node(E val):
    method Dual (line 19) | Dual(H h,E ei):h(h),ei(ei){}
    method count (line 21) | static inline size_t count(const Node *t){
    method toggle (line 25) | inline void toggle(Node *t){
    method propagate (line 30) | inline void propagate(Node *t,E x){
    method dirty (line 35) | inline bool dirty(Node *t){
    method Node (line 39) | inline Node* eval(Node* t){
      method Node (line 13) | Node(E val):
    method Node (line 53) | inline Node* pushup(Node *t){
      method Node (line 13) | Node(E val):
    method E (line 58) | inline E get_val(Node *t){
  function main (line 66) | signed main(){

FILE: bbst/rbst/data/lazy.cpp
  type Lazy (line 8) | struct Lazy{
    method Lazy (line 16) | Lazy(F f,G g,H h,Flip flip,T ti,E ei):
    type Node (line 19) | struct Node{
      method Node (line 25) | Node(T val,E laz):
    method count (line 29) | static inline size_t count(const Node *t){
    method toggle (line 33) | inline void toggle(Node *t){
    method dirty (line 40) | inline bool dirty(Node *t){
    method propagate (line 44) | inline void propagate(Node *t,E v){
    method Node (line 50) | inline Node* eval(Node* t){
      method Node (line 25) | Node(T val,E laz):
    method Node (line 64) | inline Node* pushup(Node *t){
      method Node (line 25) | Node(T val,E laz):
    method T (line 72) | inline T get_val(Node *t){
    method T (line 77) | inline T reflect(Node *t){
    method dump (line 82) | void dump(typename vector<Node>::iterator it,
    method dump (line 95) | vector<Node> dump(Node* t){
  function main (line 106) | signed main(){

FILE: bbst/rbst/data/ushi.cpp
  type Ushi (line 7) | struct Ushi{
    method Ushi (line 12) | Ushi(F f,Flip flip,T ti):f(f),flip(flip),ti(ti){}
    type Node (line 14) | struct Node{
      method Node (line 19) | Node(T val):
    method count (line 23) | static inline size_t count(const Node *t){
    method toggle (line 27) | inline void toggle(Node *t){
    method dirty (line 34) | inline bool dirty(Node *t){
    method Node (line 38) | inline Node* eval(Node* t){
      method Node (line 19) | Node(T val):
    method Node (line 47) | inline Node* pushup(Node *t){
      method Node (line 19) | Node(T val):
    method T (line 55) | inline T get_val(Node *t){
    method T (line 60) | inline T reflect(Node *t){
    method dump (line 65) | void dump(typename vector<Node>::iterator it,Node* const t,bool rev){
    method dump (line 77) | vector<Node> dump(Node* t){
  function main (line 88) | signed main(){

FILE: bbst/rbst/impl/basic.cpp
  type Basic (line 12) | struct Basic : RBST<Basic<Data, LIM>, Data, typename Data::Node, LIM>{
    method Basic (line 19) | Basic(Args... args):data(forward<Args>(args)...){}
    method Node (line 21) | inline Node* touch(Node *t){return data.eval(t);}
    method toggle (line 24) | inline void toggle(Node *t){return data.toggle(t);}
    method propagate (line 26) | inline void propagate(Node *t,E x){return data.propagate(t,x);}
    method Node (line 27) | inline Node* pushup(Node *t){return data.pushup(t);}
    method get_val (line 29) | inline decltype(auto) get_val(Node *a,size_t k){
    method query (line 34) | inline decltype(auto) query(Node *a){
  function main (line 41) | signed main(){

FILE: bbst/rbst/impl/persistent.cpp
  type Persistent (line 12) | struct Persistent : RBST<Persistent<Data, LIM>, Data, typename Data::Nod...
    method Persistent (line 19) | Persistent(Args... args):data(forward<Args>(args)...){}
    method Node (line 21) | inline Node* clone(Node *t){
    method Node (line 26) | inline Node* touch(Node *t){
    method toggle (line 37) | inline void toggle(Node *t){return data.toggle(t);}
    method propagate (line 39) | inline void propagate(Node *t,E x){return data.propagate(t,x);}
    method Node (line 40) | inline Node* pushup(Node *t){return data.pushup(t);}
    method get_val (line 42) | inline decltype(auto) get_val(Node *a,size_t k){
    method query (line 47) | decltype(auto) query(Node *a,size_t l,size_t r){
    method almost_full (line 54) | bool almost_full() const{
    method Node (line 58) | Node* rebuild(Node* a){
  function JOISC2012_COPYPASTE (line 71) | signed JOISC2012_COPYPASTE(){
  function ARC030_D (line 118) | signed ARC030_D(){
  function main (line 186) | signed main(){

FILE: bbst/rbst/rbst.cpp
  type RBST (line 7) | struct RBST{
    method u32 (line 9) | u32 xor128(){
    method Node (line 25) | inline Node* create(Args&&... args){
    method count (line 29) | inline size_t count(const Node *t){return Data::count(t);}
    method Node (line 31) | inline Node* touch(Node *t){
    method toggle (line 35) | inline void toggle(Node *t){
    method Node (line 39) | inline Node* pushup(Node *t){
    method Node (line 43) | Node* toggle(Node *a,size_t l,size_t r){
    method Node (line 51) | Node* merge(Node* a,Node* b){
    method split (line 66) | pair<Node*, Node*> split(Node* a,size_t k){
    method Node (line 83) | Node* insert(Node *a,size_t k,Node v){
    method Node (line 89) | Node* erase(Node *a,size_t k){
    method Node (line 96) | Node* find_by_order(Node *a,size_t k){
    method is_right (line 105) | inline bool is_right(Node* a){
    method order_of_key (line 109) | size_t order_of_key(Node* a){
    method Node (line 118) | Node* build(size_t l,size_t r,const vector<Node> &vs){
    method Node (line 124) | Node* build(const vector<Node> &vs){
    method Node (line 129) | Node* set_val(Node *a,size_t k,T val){
    method Node (line 139) | Node* get_val(Node *a,size_t k){
    method Node (line 149) | Node* update(Node *a,size_t l,size_t r,E v){
    method query (line 157) | decltype(auto) query(Node *&a,size_t l,size_t r){
  function main (line 169) | signed main(){

FILE: bflow/capacityscaling.cpp
  type Objective (line 8) | enum Objective{
  type MinCostFlow (line 14) | struct MinCostFlow{
    method chmin (line 15) | inline void chmin(T &x,T y){x=min(x,y);}
    type Edge (line 17) | struct Edge{
      method Edge (line 22) | Edge(int src,int dst,Flow cap,Cost cost,int rev):
      method Flow (line 24) | Flow residual_cap()const{return cap-flow;}
    type EdgePtr (line 27) | struct EdgePtr{
      method EdgePtr (line 29) | EdgePtr(int v,int e):v(v),e(e){}
    method MinCostFlow (line 37) | MinCostFlow(int n):n(n),G(n),b(n,0){}
    method EdgePtr (line 39) | EdgePtr add_edge(int src,int dst,Flow lower,Flow upper,Cost cost){
      method EdgePtr (line 29) | EdgePtr(int v,int e):v(v),e(e){}
    method Edge (line 48) | const Edge &get_edge(EdgePtr ep)const{return G[ep.v][ep.e];}
      method Edge (line 22) | Edge(int src,int dst,Flow cap,Cost cost,int rev):
      method Flow (line 24) | Flow residual_cap()const{return cap-flow;}
    method push (line 50) | void push(Edge &e,Flow amount){
    method add_supply (line 55) | void add_supply(int v,Flow amount){b[v]+=amount;}
    method add_demand (line 56) | void add_demand(int v,Flow amount){b[v]-=amount;}
    method Cost (line 58) | Cost residual_cost(const Edge &e){
    method saturate_negative (line 63) | void saturate_negative(const Flow delta){
    type P (line 89) | struct P{
      method P (line 92) | P(Cost first,int second):first(first),second(second){}
    method eliminate (line 99) | void eliminate(vector<int> &vs,Predicate predicate){
    method dual (line 103) | bool dual(const Flow delta){
    method primal (line 141) | void primal(const Flow delta){
    method build (line 166) | bool build(){
    method T (line 185) | T get_cost(){
    method T (line 192) | T get_gain(){return get_cost();}
    method get_potential (line 194) | vector<Cost> get_potential(){
  function main (line 210) | signed main(){

FILE: combinatorics/bell.cpp
  function M (line 13) | M bell(int n,int k){
  function main (line 32) | signed main(){

FILE: combinatorics/bernoulli.cpp
  type Bernoulli (line 14) | struct Bernoulli : FormalPowerSeries<M_>{
    method build (line 21) | void build(int n){
    method M (line 29) | M operator[](int k)const{return rs[k];}
  function main (line 34) | signed main(){

FILE: combinatorics/enumeration.cpp
  class Enumeration (line 8) | class Enumeration{
    method init (line 13) | static void init(int n){
    method M (line 30) | static M Fact(int n){
    method M (line 34) | static M Finv(int n){
    method M (line 38) | static M Invs(int n){
    method M (line 43) | static M C(int n,int k){
    method M (line 49) | static M P(int n,int k){
    method M (line 56) | static M H(int n,int k){
  function main (line 66) | signed main(){

FILE: combinatorics/partition.cpp
  type Partition (line 14) | struct Partition : FormalPowerSeries<M_>{
    method build (line 21) | void build(int n){
    method M (line 31) | M operator[](int k)const{return rs[k];}
  function main (line 36) | signed main(){

FILE: combinatorics/partitiontable.cpp
  type PartitionTable (line 8) | struct PartitionTable{
    method PartitionTable (line 10) | PartitionTable(int h,int w):dp(h+1,vector<M>(w+1,0)){
    method M (line 21) | M operator()(int n,int k){return dp[n][k];}
    method M (line 24) | M operator()(int n){return dp[n][n];}
  function main (line 29) | signed main(){

FILE: combinatorics/stirling1st.cpp
  type Stirling1st (line 13) | struct Stirling1st : FormalPowerSeries<M_>{
    method build (line 20) | void build(int n){
    method M (line 52) | M operator[](int k)const{return rs[k];}
  function main (line 57) | signed main(){

FILE: combinatorics/stirling2nd.cpp
  type Stirling2nd (line 13) | struct Stirling2nd : FormalPowerSeries<M_>{
    method build (line 20) | void build(int n){
    method M (line 30) | M operator[](int k)const{return rs[k];}
  function main (line 35) | signed main(){

FILE: combinatorics/surjection.cpp
  function M (line 13) | M surjection(int n,int k){
  function main (line 26) | signed main(){

FILE: convexhulltrick/convexhulltrick.cpp
  type Objective (line 6) | enum Objective{
  type Line (line 11) | struct Line {
    method T (line 13) | T operator()(const T x)const{return k*x+m;}
  type ConvexHullTrick (line 17) | struct ConvexHullTrick : deque<Line<T>>{
    method sgn (line 18) | inline int sgn(T x){return x==0?0:(x<0?-1:1);}
    method check (line 21) | inline bool check(const Line<T> &a,const Line<T> &b,const Line<T> &c){
    method at (line 34) | const Line<T> at(int i) const{return (*this)[i];}
    method add (line 36) | void add(T k_,T m_){
    method T (line 60) | T query(T x){
    method T (line 71) | T queryMonotoneInc(T x){
    method T (line 77) | T queryMonotoneDec(T x){
    method getVertices (line 83) | vector<pair<T, T>> getVertices(){
  function chmin (line 100) | void chmin(optional<T> &a,const T& b){if(!a or *a>b) a=b;}
  function solve_lp (line 104) | optional<T> solve_lp(T p0,T p1,vector<T> as,vector<T> bs,vector<T> cs){
  function T (line 125) | T solve_lp_min(T p0,T p1,vector<T> as,vector<T> bs,vector<T> cs){
  function T (line 141) | T solve_lp_max(T p0,T p1,vector<T> as,vector<T> bs,vector<T> cs){
  function ARC128_C (line 158) | signed ARC128_C(){
  function main (line 182) | signed main(){

FILE: convexhulltrick/linecontainer.cpp
  type Objective (line 6) | enum Objective{
  type Line (line 12) | struct Line {
  function T (line 18) | T lc_inf(){return numeric_limits<T>::max();}
  function T (line 21) | T lc_div(T a,T b){return a/b-((a^b)<0 and a%b);}
  function lc_div (line 22) | double lc_div(double a,double b){return a/b;}
  type LineContainer (line 25) | struct LineContainer : multiset<Line<T>, less<>>{
    method insect (line 30) | bool insect(typename super::iterator x,typename super::iterator y){
    method add (line 36) | void add(T k,T m){
    method T (line 42) | T query(T x){
  function main (line 56) | signed main(){

FILE: convexhulltrick/segmentcontainer.cpp
  type Objective (line 6) | enum Objective{
  type SegmentContainer (line 12) | struct SegmentContainer{
    type Segment (line 14) | struct Segment{
      method T (line 16) | T operator()(T x) const{return a*x+b;}
    method SegmentContainer (line 22) | SegmentContainer(const vector<T> &xs_):xs(xs_){
    method index (line 29) | inline int index(T x) const{
    method add (line 34) | void add(T a,T b,T xl,T xr){
    method update (line 42) | void update(Segment g,int i){
    method T (line 57) | T query(T x){
  function main (line 70) | signed main(){

FILE: convexhulltrick/withindex.cpp
  type ConvexHullTrickWithIndex (line 6) | struct ConvexHullTrickWithIndex {
    type P (line 7) | struct P{
      method P (line 10) | P(T m,T b,int idx):m(m),b(b),idx(idx){}
    method empty (line 17) | bool empty()const{return H.empty();}
    method clear (line 18) | void clear(){H.clear();}
    method sgn (line 20) | inline int sgn(T x){return x==0?0:(x<0?-1:1);}
    method check (line 23) | inline bool check(const P &a,const P &b,const P &c){
    method addLine (line 30) | void addLine(T m,T b,int idx){
    method getY (line 56) | inline pair<T, int> getY(const P &a,const T &x){
    method query (line 60) | pair<T, int> query(T x){
    method queryMonotoneInc (line 72) | pair<T, int> queryMonotoneInc(T x){
    method queryMonotoneDec (line 79) | pair<T, int> queryMonotoneDec(T x){
  function main (line 88) | signed main(){

FILE: convolution/arbitrarymod.cpp
  type ArbitraryMod (line 12) | struct ArbitraryMod{
    method multiply (line 16) | vector<T> multiply(vector<T> as,vector<T> bs){
  function main (line 62) | signed main(){

FILE: convolution/bitwise/and.cpp
  type bitwise_and (line 6) | namespace bitwise_and{
  function main (line 13) | signed main(){

FILE: convolution/bitwise/fwht.cpp
  function fwht (line 9) | void fwht(vector<T> &as,F f){
  function main (line 19) | signed main(){

FILE: convolution/bitwise/or.cpp
  type bitwise_or (line 6) | namespace bitwise_or{
  function main (line 13) | signed main(){

FILE: convolution/bitwise/xor.cpp
  type bitwise_xor (line 6) | namespace bitwise_xor{
  function main (line 21) | signed main(){

FILE: convolution/convolution2D.cpp
  type Convolution2D (line 7) | struct Convolution2D{
    method Convolution2D (line 10) | Convolution2D(Transformer tran):tran(tran){}
    method transpose (line 12) | void transpose(Matrix &as){
    method transform (line 21) | void transform(Matrix &as,bool f){
    method Matrix (line 28) | Matrix multiply(Matrix as,Matrix bs){

FILE: convolution/divisor.cpp
  type DivisorTransform (line 8) | namespace DivisorTransform{
    function inc (line 10) | void inc(vector<T> &as,F f){
    function dec (line 23) | void dec(vector<T> &as,F f){
  type GCDConvolution (line 36) | namespace GCDConvolution{
    function zeta (line 38) | void zeta(vector<T> &as){
    function moebius (line 43) | void moebius(vector<T> &as){
  type LCMConvolution (line 48) | namespace LCMConvolution{
    function zeta (line 50) | void zeta(vector<T> &as){
    function moebius (line 55) | void moebius(vector<T> &as){
  function main (line 63) | signed main(){

FILE: convolution/fastfouriertransform.cpp
  type FFT (line 6) | namespace FFT{
    type num (line 9) | struct num{
      method num (line 11) | num(){x=y=0;}
      method num (line 12) | num(dbl x,dbl y):x(x),y(y){}
    function num (line 15) | inline num operator+(num a,num b){
      method num (line 11) | num(){x=y=0;}
      method num (line 12) | num(dbl x,dbl y):x(x),y(y){}
    function num (line 18) | inline num operator-(num a,num b){
      method num (line 11) | num(){x=y=0;}
      method num (line 12) | num(dbl x,dbl y):x(x),y(y){}
    function num (line 21) | inline num operator*(num a,num b){
      method num (line 11) | num(){x=y=0;}
      method num (line 12) | num(dbl x,dbl y):x(x),y(y){}
    function num (line 24) | inline num conj(num a){
      method num (line 11) | num(){x=y=0;}
      method num (line 12) | num(dbl x,dbl y):x(x),y(y){}
    function ensure_base (line 34) | void ensure_base(int nbase){
    function fft (line 53) | void fft(vector<num> &as){
    function multiply (line 76) | vector<long long> multiply(vector<T> &as,vector<T> &bs){
  function main (line 111) | signed main(){

FILE: convolution/garner.cpp
  type Garner (line 12) | struct Garner{
    method pow (line 18) | static constexpr int pow(int a,int b,int md){
    method inv (line 29) | static constexpr int inv(int x,int md){
    method garner (line 33) | inline void garner(int &c0,int c1,int c2,int m01,int MOD){
    method garner (line 52) | inline void garner(vector< vector<int> > &cs,int MOD){
    method multiply (line 58) | vector<int> multiply(vector<int> as,vector<int> bs,int MOD){
    method multiply (line 70) | decltype(auto) multiply(vector<T> am,
  function main (line 83) | signed main(){

FILE: convolution/naive.cpp
  function naive (line 8) | decltype(auto) naive(){
  function main (line 21) | signed main(){

FILE: convolution/numbertheoretictransform.cpp
  function bmds (line 11) | constexpr int bmds(int x){
  function brts (line 16) | constexpr int brts(int x){
  type NTT (line 22) | struct NTT{
    method ensure_base (line 28) | void ensure_base(int n){
    method ntt (line 44) | void ntt(vector<M> &as,bool f){
    method multiply (line 70) | vector<M> multiply(vector<M> as,vector<M> bs){
    method multiply (line 85) | vector<int> multiply(vector<int> as,vector<int> bs){
  function main (line 97) | signed main(){

FILE: datastructure/BIT2D.cpp
  type BIT2D (line 7) | struct BIT2D{
    method BIT2D (line 12) | BIT2D():n(-1),m(-1){}
    method BIT2D (line 13) | BIT2D(int n_,int m_):n(n_),m(m_),bit(n_+1,vector<T>(m+1,0)){}
    method T (line 14) | T sum(int i,int j){
    method add (line 21) | void add(int i,int j,T a){
    method T (line 28) | T sum(int x1,int y1,int x2,int y2){
  function main (line 34) | signed main(){

FILE: datastructure/absolutesum.cpp
  type AbsoluteSum (line 7) | struct AbsoluteSum{
    method AbsoluteSum (line 10) | AbsoluteSum():sum(0){}
    method T (line 11) | T insert(T x){
    method T (line 34) | T erase(T x){
    method interval (line 59) | pair<T, T> interval(){
    method T (line 64) | T value(){return sum;}
  function ABC127_F (line 71) | signed ABC127_F(){
  function main (line 100) | signed main(){

FILE: datastructure/binaryindexedtree.cpp
  class BIT (line 8) | class BIT{
    method T (line 11) | T sum(int i){
    method BIT (line 20) | BIT(int n_):n(n_+1),bit(n_+2,0){}
    method add (line 23) | void add(int i,T a){
    method T (line 29) | T query(int l,int r){return sum(r)-sum(l);}
    method lower_bound (line 32) | int lower_bound(const T w){
    method upper_bound (line 49) | int upper_bound(T w){return lower_bound(w+1);}
  function main (line 53) | signed main(){

FILE: datastructure/binarytrie.cpp
  type BinaryTrie (line 7) | struct BinaryTrie{
    type Node (line 8) | struct Node{
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method BinaryTrie (line 16) | BinaryTrie():acc(0){root=emplace(nullptr);}
    method clear (line 18) | void clear(Node *a){
    method Node (line 24) | inline Node* emplace(Node* p){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method count (line 28) | inline size_t count(Node* a){
    method add (line 32) | void add(const T b,size_t k=1){
    method update (line 45) | inline void update(const T b){acc^=b;}
    method Node (line 47) | Node* find(const T b){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method Node (line 58) | Node* check(Node *a){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method sub (line 64) | void sub(Node* a,size_t k=1){
    method Node (line 74) | Node* xmax(const T b){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method Node (line 86) | Node* xmin(const T b){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method Node (line 90) | Node* ge(Node *a,int i){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method Node (line 98) | Node* next(Node* a,int i){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method Node (line 106) | Node* lower_bound(const T b){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method Node (line 119) | Node* upper_bound(const T b){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method T (line 123) | T val(Node* a){
    method Node (line 133) | Node* find_by_order(size_t k){
      method Node (line 11) | Node(Node* p):cnt(0),p(p){l=r=nullptr;}
    method order_of_key (line 148) | size_t order_of_key(const T b){
  function ARC033_C (line 166) | signed ARC033_C(){
  function CFR477_C (line 188) | signed CFR477_C(){
  function main (line 239) | signed main(){

FILE: datastructure/bitvector.cpp
  type BitVector (line 9) | struct BitVector{
    method BitVector (line 13) | BitVector(size_t n_):n(n_),dat(n_/B+1,0){}
    method T (line 15) | inline T get(size_t i)const{return (dat[i/B]>>(i%B))&T(1);}
    method set (line 17) | void set(size_t i,T v){
    method BitVector (line 23) | BitVector get(size_t l,size_t r)const{
    method set (line 45) | void set(size_t l,size_t r,const BitVector& bv){
  function main (line 64) | signed main(){

FILE: datastructure/cartesiantree.cpp
  function cartesian_tree (line 8) | vector<int> cartesian_tree(const vector<T> &vs){
  function main (line 31) | signed main(){

FILE: datastructure/cumulativesum.cpp
  type CumulativeSum (line 7) | struct CumulativeSum{
    method CumulativeSum (line 9) | CumulativeSum(const vector<T> &as){
    method T (line 17) | T query(int l,int r){return -sm[l]+sm[r];}
  function main (line 22) | signed main(){

FILE: datastructure/disjointsparsetable.cpp
  type DisjointSparseTable (line 7) | struct DisjointSparseTable{
    method DisjointSparseTable (line 13) | DisjointSparseTable(F f):f(f){}
    method build (line 15) | void build(const vector<T> &vs){
    method T (line 37) | T query(int l,int r){
  function CODECHEF_SEGPROD (line 47) | signed CODECHEF_SEGPROD(){
  function main (line 88) | signed main(){

FILE: datastructure/kdtree.cpp
  type KDTree (line 7) | struct KDTree{
    class Node (line 10) | class Node{
      method Node (line 13) | Node(){pos=p=l=r=NIL;}
    class Point (line 16) | class Point{
      method Point (line 20) | Point(int id,T x,T y): id(id),x(x),y(y){}
    method add_point (line 30) | void add_point(int i,int x,int y){
    method lessX (line 35) | static bool lessX(const Point &p1,const Point &p2){return p1.x<p2.x;}
    method lessY (line 36) | static bool lessY(const Point &p1,const Point &p2){return p1.y<p2.y;}
    method dfs (line 38) | int dfs(int l,int r,int depth){
    method build (line 53) | int build(){
    method find (line 59) | void find(int v,T sx,T tx,T sy,T ty,int depth,vector<Point> &ans){
  function main (line 84) | signed main(){

FILE: datastructure/pb_ds_cc_hash_table.cpp
  function main (line 13) | signed main(){

FILE: datastructure/prioritysum.cpp
  type PrioritySum (line 7) | struct PrioritySum{
    method PrioritySum (line 12) | PrioritySum():num(0),sum(identity){}
    method PrioritySum (line 13) | PrioritySum(size_t num):num(num),sum(identity){}
    method resolve (line 15) | void resolve(){
    method T (line 38) | T query(){resolve();return sum;}
    method push (line 40) | void push(const T &x){pq1.emplace(x);}
    method expand (line 41) | void expand(){num++;}
    method shrink (line 42) | void shrink(){assert(num);num--;}
    method size (line 44) | size_t size()const{return pq1.size()+pq2.size();}
  type FastIO (line 53) | struct FastIO{
    method FastIO (line 54) | FastIO(){
  function chmin (line 60) | inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
  function chmax (line 61) | inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
  function ARC074_D (line 64) | signed ARC074_D(){
  function CGR002_F (line 97) | signed CGR002_F(){
  function main (line 207) | signed main(){

FILE: datastructure/quickfind.cpp
  type QuickFind (line 6) | struct QuickFind{
    method QuickFind (line 9) | QuickFind(int n):rs(n,1),ps(n),vs(n){
    method find (line 13) | int find(int x) const{return ps[x];}
    method same (line 14) | bool same(int x,int y) const{
    method unite (line 17) | void unite(int x,int y){
  function main (line 33) | signed main(){

FILE: datastructure/radixheap.cpp
  type RadixHeap (line 9) | struct RadixHeap{
    method RadixHeap (line 15) | RadixHeap():size(0),last(0){}
    method empty (line 17) | bool empty() const{return size==0;}
    method getbit (line 19) | inline int getbit(int a){
    method getbit (line 23) | inline int getbit(long long a){
    method emplace (line 27) | void emplace(K key,V val){
    method pop (line 32) | pair<K, V> pop(){
  function main (line 49) | signed main(){

FILE: datastructure/rangeslide.cpp
  type RangeSlide (line 7) | struct RangeSlide{
    method RangeSlide (line 11) | RangeSlide(vector<T> vs,F cmp):vs(vs),cmp(cmp){}
    method add_range (line 13) | void add_range(size_t l,size_t r){
    method build (line 18) | vector<size_t> build(){
  function main (line 42) | signed main(){

FILE: datastructure/rotcev.cpp
  type Rotcev (line 8) | struct Rotcev{
    method size (line 11) | size_t size()const{return data.size();}
    method empty (line 12) | bool empty()const{return data.empty();}
    method T (line 14) | T& operator[](size_t n){return data[size()-1-n];}
    method T (line 15) | const T& operator[](size_t n)const{return data[size()-1-n];}
    method push_front (line 17) | void push_front(T val){data.push_back(val);}
    method pop_front (line 18) | void pop_front(){data.pop_back();}
    method clear (line 19) | void clear(){data.clear();}
    method Rotcev (line 22) | Rotcev(Args ...args):data(forward<Args>(args)...){}
    method emplace_front (line 24) | void emplace_front(Args ...args){data.emplace_back(forward<Args>(args)...
    method assign (line 26) | void assign(Args ...args){data.assign(forward<Args>(args)...);}
  function main (line 30) | signed main(){

FILE: datastructure/skewheap.cpp
  type SkewHeap (line 7) | struct SkewHeap{
    method SkewHeap (line 16) | SkewHeap(G g,H h,C c,T INF,E ei):g(g),h(h),c(c),INF(INF),ei(ei){}
    type Node (line 18) | struct Node{
      method Node (line 22) | Node(T val,E add):val(val),add(add){l=r=nullptr;}
    method eval (line 25) | void eval(Node *a){
    method T (line 34) | T top(Node *a){
    method T (line 38) | T snd(Node *a){
    method Node (line 43) | Node* add(Node *a,E d){
      method Node (line 22) | Node(T val,E add):val(val),add(add){l=r=nullptr;}
    method Node (line 48) | Node* push(T v){
      method Node (line 22) | Node(T val,E add):val(val),add(add){l=r=nullptr;}
    method Node (line 52) | Node* meld(Node *a,Node *b){
      method Node (line 22) | Node(T val,E add):val(val),add(add){l=r=nullptr;}
    method Node (line 61) | Node* pop(Node* a){
      method Node (line 22) | Node(T val,E add):val(val),add(add){l=r=nullptr;}
  function APC001_D (line 75) | signed APC001_D(){
  function main (line 138) | signed main(){

FILE: datastructure/slidingwindowaggregation.cpp
  type SWAG (line 7) | struct SWAG{
    method SWAG (line 15) | SWAG(F1 f1,F2 f2,S id):f1(f1),f2(f2),id(id),ls(1,id),rs(1,id){}
    method SWAG (line 18) | SWAG(F1 f1,S id):f1(f1),f2([&](T y,S x){return f1(y,x);}),
    method push (line 21) | void push(T x){
    method pop (line 26) | void pop(){
    method fold (line 41) | void fold(Q q){q(ls.back(),rs.back());}
  class Crypto (line 53) | class Crypto {
    method Crypto (line 55) | Crypto() {
    method decode (line 60) | int decode(int z) {
    method query (line 68) | void query(long long z) {
    method swap_data (line 82) | void swap_data(int i, int j) {
    method seed (line 88) | void seed() {
    method next (line 109) | uint8_t next() {
  function JAG2018_DAY2_D (line 117) | signed JAG2018_DAY2_D(){
  function main (line 184) | signed main(){

FILE: datastructure/slope.cpp
  type Slope (line 8) | struct Slope{
    type PQ (line 11) | struct PQ{
      method empty (line 16) | bool empty()const{return pq.empty();}
      method PQ (line 19) | PQ():offset(0){}
      method compare (line 20) | bool compare(T a){return comp(a,pq.top().first+offset);}
      method shift (line 23) | void shift(T diff){offset+=diff;}
      method push (line 25) | void push(T pos,T num){
      method P (line 29) | P pop(){
    method Slope (line 38) | Slope():entire(0){}
    method T (line 40) | inline T relu(T x){return max<T>(0,x);}
    method fix (line 43) | void fix(T a,T cnt,From &from,To &to){
    method add_x_minus_a (line 58) | void add_x_minus_a(T a,T cnt=T(1)){
    method add_a_minus_x (line 63) | void add_a_minus_x(T a,T cnt=T(1)){
    method shift (line 68) | void shift(T a,T b){
    method shift (line 75) | void shift(T a){shift(a,a);}
    method apply_cumulative_min (line 78) | void apply_cumulative_min(){
    method T (line 82) | T get_min(){return entire;}
    method T (line 84) | T get_val(T x){
  function ABC217_H (line 102) | signed ABC217_H(){
  function main (line 127) | signed main(){

FILE: datastructure/sparsetable.cpp
  type SparseTable (line 7) | struct SparseTable{
    method SparseTable (line 13) | SparseTable(F f):f(f){}
    method build (line 15) | void build(const vector<T> &v){
    method T (line 28) | T query(int a,int b){
  function main (line 35) | signed main(){

FILE: datastructure/unionfind.cpp
  type UnionFind (line 6) | struct UnionFind{
    method UnionFind (line 9) | UnionFind(int n):num(n),rs(n,1),ps(n,0){
    method find (line 12) | int find(int x){
    method same (line 15) | bool same(int x,int y){
    method unite (line 18) | void unite(int x,int y){
    method size (line 26) | int size(int x){
    method count (line 29) | int count() const{
  function main (line 36) | signed main(){

FILE: datastructure/waveletmatrix.cpp
  type FullyIndexableDictionary (line 7) | struct FullyIndexableDictionary{
    method FullyIndexableDictionary (line 12) | FullyIndexableDictionary(){}
    method FullyIndexableDictionary (line 13) | FullyIndexableDictionary(int len)
    method set (line 16) | void set(int k){
    method build (line 20) | void build(){
    method rank (line 30) | int rank(int k){
    method rank (line 34) | int rank(bool v,int k){
    method select (line 38) | int select(bool v,int k){
    method select (line 49) | int select(bool v,int i,int l){
  type WaveletMatrix (line 55) | struct WaveletMatrix{
    method WaveletMatrix (line 61) | WaveletMatrix(vector<T> data){
    method T (line 79) | T access(int k){
    method rank (line 90) | int rank(T v,int k){
    method select (line 102) | int select(T v,int k){
    method select (line 113) | int select(T v,int k,int l){
    method T (line 118) | T quantile(int l,int r,int k){
    method T (line 137) | T rquantile(int l,int r,int k){
    method freq_dfs (line 141) | int freq_dfs(int d,int l,int r,T val,T a,T b){
    method rangefreq (line 154) | int rangefreq(int left,int right,T lower,T upper){
    method ll (line 158) | pair<int, int> ll(int l,int r,T v){
    method lt (line 170) | int lt(int l,int r,T v){
    method le (line 175) | int le(int l,int r,T v){
    method T (line 180) | T succ(int l,int r,T v){
    method T (line 185) | T pred(int l,int r,T v){
  function main (line 193) | signed main(){

FILE: datastructure/weightedunionfind.cpp
  type WeightedUnionFind (line 7) | struct WeightedUnionFind{
    method WeightedUnionFind (line 11) | WeightedUnionFind(int n):rs(n,1),ps(n),ws(n,T(0)){
    method find (line 15) | int find(int x){
    method T (line 22) | T weight(int x){
    method same (line 27) | bool same(int x,int y){
    method unite (line 31) | void unite(int x,int y,T w){
    method T (line 42) | T diff(int x,int y){
  function main (line 48) | signed main(){

FILE: formalpowerseries/998244353.cpp
  type fps_998244353 (line 14) | namespace fps_998244353{
  function main (line 25) | signed main(){

FILE: formalpowerseries/base.cpp
  type FormalPowerSeries (line 13) | struct FormalPowerSeries : Enumeration<M_> {
    method FormalPowerSeries (line 23) | FormalPowerSeries(Conv conv):conv(conv){}
    method Poly (line 25) | Poly pre(const Poly &as,int deg){
    method Poly (line 29) | Poly add(Poly as,Poly bs){
    method Poly (line 37) | Poly sub(Poly as,Poly bs){
    method Poly (line 45) | Poly mul(Poly as,Poly bs){
    method Poly (line 49) | Poly mul(Poly as,M k){
    method is_zero (line 54) | bool is_zero(Poly as){
    method shrink (line 58) | void shrink(Poly &as){
  function main (line 93) | signed main(){

FILE: formalpowerseries/diff.cpp
  function main (line 22) | signed main(){

FILE: formalpowerseries/div.cpp
  function main (line 28) | signed main(){

FILE: formalpowerseries/exp.cpp
  function main (line 27) | signed main(){

FILE: formalpowerseries/integral.cpp
  function main (line 24) | signed main(){

FILE: formalpowerseries/inv.cpp
  function main (line 24) | signed main(){

FILE: formalpowerseries/log.cpp
  function main (line 22) | signed main(){

FILE: formalpowerseries/mod.cpp
  function main (line 26) | signed main(){

FILE: formalpowerseries/pow.cpp
  function main (line 37) | signed main(){

FILE: formalpowerseries/shift.cpp
  function main (line 29) | signed main(){

FILE: formalpowerseries/sqrt.cpp
  function main (line 27) | signed main(){

FILE: geometry/3D/geometry3D.cpp
  type Point3D (line 8) | struct Point3D{
    method Point3D (line 10) | Point3D(){}
    method Point3D (line 11) | Point3D(double x,double y,double z):x(x),y(y),z(z){}
    method Point3D (line 12) | Point3D operator+(Point3D p) {return Point3D(x+p.x,y+p.y,z+p.z);}
    method Point3D (line 13) | Point3D operator-(Point3D p) {return Point3D(x-p.x,y-p.y,z-p.z);}
    method Point3D (line 14) | Point3D operator*(double k){return Point3D(x*k,y*k,z*k);}
    method Point3D (line 15) | Point3D operator/(double k){return Point3D(x/k,y/k,z/k);}
    method Point3D (line 16) | Point3D operator*(Point3D p){
    method norm (line 22) | double norm(){return x*x+y*y+z*z;}
    method abs (line 23) | double abs(){return sqrt(norm());}
  function istream (line 33) | istream &operator >> (istream &is,Point3D &p){
  function ostream (line 37) | ostream &operator << (ostream &os,Point3D p){
  type Segment3D (line 45) | struct Segment3D{
    method Segment3D (line 47) | Segment3D(){}
    method Segment3D (line 48) | Segment3D(Point3D p1, Point3D p2):p1(p1),p2(p2){}
  function istream (line 52) | istream &operator >> (istream &is,Segment3D &s){
  type Sphere (line 57) | struct Sphere{
    method Sphere (line 60) | Sphere(){}
    method Sphere (line 61) | Sphere(Point3D c,double r):c(c),r(r){}
  function istream (line 64) | istream &operator >> (istream &is,Sphere &c){
  function norm (line 69) | double norm(Vector3D a){
  function abs (line 72) | double abs(Vector3D a){
  function dot (line 75) | double dot(Vector3D a,Vector3D b){
  function Vector3D (line 78) | Vector3D cross(Vector3D a,Vector3D b){
  function Point3D (line 82) | Point3D project(Line3D l,Point3D p){
    method Point3D (line 10) | Point3D(){}
    method Point3D (line 11) | Point3D(double x,double y,double z):x(x),y(y),z(z){}
    method Point3D (line 12) | Point3D operator+(Point3D p) {return Point3D(x+p.x,y+p.y,z+p.z);}
    method Point3D (line 13) | Point3D operator-(Point3D p) {return Point3D(x-p.x,y-p.y,z-p.z);}
    method Point3D (line 14) | Point3D operator*(double k){return Point3D(x*k,y*k,z*k);}
    method Point3D (line 15) | Point3D operator/(double k){return Point3D(x/k,y/k,z/k);}
    method Point3D (line 16) | Point3D operator*(Point3D p){
    method norm (line 22) | double norm(){return x*x+y*y+z*z;}
    method abs (line 23) | double abs(){return sqrt(norm());}
  function Point3D (line 88) | Point3D reflect(Line3D l,Point3D p){
    method Point3D (line 10) | Point3D(){}
    method Point3D (line 11) | Point3D(double x,double y,double z):x(x),y(y),z(z){}
    method Point3D (line 12) | Point3D operator+(Point3D p) {return Point3D(x+p.x,y+p.y,z+p.z);}
    method Point3D (line 13) | Point3D operator-(Point3D p) {return Point3D(x-p.x,y-p.y,z-p.z);}
    method Point3D (line 14) | Point3D operator*(double k){return Point3D(x*k,y*k,z*k);}
    method Point3D (line 15) | Point3D operator/(double k){return Point3D(x/k,y/k,z/k);}
    method Point3D (line 16) | Point3D operator*(Point3D p){
    method norm (line 22) | double norm(){return x*x+y*y+z*z;}
    method abs (line 23) | double abs(){return sqrt(norm());}
  function getDistanceLP (line 92) | double getDistanceLP(Line3D l,Point3D p){
  function getDistanceSP (line 96) | double getDistanceSP(Segment3D s,Point3D p){
  function intersectSC (line 102) | bool intersectSC(Segment3D s,Sphere c){
  type ConvexHull3D (line 108) | struct ConvexHull3D{
    type face (line 109) | struct face{
      method face (line 112) | face(){}
      method face (line 113) | face(int a,int b,int c,bool ok):a(a),b(b),c(c),ok(ok){}
    method ConvexHull3D (line 120) | ConvexHull3D(int n):n(n),p(n),f(n*8),g(n,vector<int>(n)){}
    method input (line 122) | void input(){
    method dblcmp (line 126) | double dblcmp(Point3D q,face f){
    method deal (line 133) | void deal(int q,int a,int b){
    method dfs (line 146) | void dfs(int q,int now){
    method build (line 153) | void build(){
    method volume (line 204) | double volume(Point3D a,Point3D b,Point3D c,Point3D d){
    method same (line 208) | bool same(int s,int t){
    method polygon (line 217) | int polygon(){
    method triangle (line 228) | int triangle(){
    method area (line 232) | double area(Point3D a,Point3D b,Point3D c){
    method Point3D (line 236) | Point3D cross(Point3D a,Point3D b,Point3D c){
    method area (line 242) | double area(){
  function main (line 258) | signed main(){

FILE: geometry/argsort.cpp
  function argsort (line 8) | void argsort(vector<P> &ps){
  function main (line 29) | signed main(){

FILE: geometry/geometry.cpp
  type geometry (line 9) | namespace geometry {
    type Point (line 13) | struct Point{
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function sort_x (line 35) | bool sort_x(Point a,Point b){
    function sort_y (line 39) | bool sort_y(Point a,Point b){
    type Segment (line 46) | struct Segment{
      method Segment (line 48) | Segment(){}
      method Segment (line 49) | Segment(Point p1, Point p2):p1(p1),p2(p2){}
    type Circle (line 53) | struct Circle{
      method Circle (line 56) | Circle(){}
      method Circle (line 57) | Circle(Point c,double r):c(c),r(r){}
    function norm (line 60) | double norm(Vector a){
    function abs (line 64) | double abs(Vector a){
    function dot (line 68) | double dot(Vector a,Vector b){
    function cross (line 72) | double cross(Vector a,Vector b){
    function Point (line 76) | Point orth(Point p){return Point(-p.y,p.x);}
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function isOrthogonal (line 78) | bool isOrthogonal(Vector a,Vector b){
    function isOrthogonal (line 82) | bool isOrthogonal(Point a1,Point a2,Point b1,Point b2){
    function isOrthogonal (line 86) | bool isOrthogonal(Segment s1,Segment s2){
    function isParallel (line 90) | bool isParallel(Vector a,Vector b){
    function isParallel (line 94) | bool isParallel(Point a1,Point a2,Point b1,Point b2){
    function isParallel (line 98) | bool isParallel(Segment s1,Segment s2){
    function Point (line 102) | Point project(Segment s,Point p){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function Point (line 108) | Point reflect(Segment s,Point p){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function arg (line 112) | double arg(Vector p){
    function Vector (line 116) | Vector polar(double a,double r){
    function ccw (line 127) | int ccw(Point p0,Point p1,Point p2){
    function intersectSS (line 137) | bool intersectSS(Point p1,Point p2,Point p3,Point p4){
    function intersectSS (line 142) | bool intersectSS(Segment s1,Segment s2){
    function intersectPS (line 146) | bool intersectPS(Polygon p,Segment l){
    function getDistanceLP (line 153) | double getDistanceLP(Line l,Point p){
    function getDistanceSP (line 157) | double getDistanceSP(Segment s,Point p){
    function getDistanceSS (line 163) | double getDistanceSS(Segment s1,Segment s2){
    function intersectCC (line 176) | int intersectCC(Circle c1,Circle c2){
    function intersectSC (line 187) | bool intersectSC(Segment s,Circle c){
    function intersectCS (line 191) | int intersectCS(Circle c,Segment s){
    function Point (line 201) | Point getCrossPointSS(Segment s1,Segment s2){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function Point (line 214) | Point getCrossPointLL(Line l1,Line l2){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function Polygon (line 221) | Polygon getCrossPointCL(Circle c,Line l){
    function Polygon (line 235) | Polygon getCrossPointCS(Circle c,Segment s){
    function Polygon (line 247) | Polygon getCrossPointCC(Circle c1,Circle c2){
    function contains (line 258) | int contains(Polygon g,Point p){
    function Polygon (line 270) | Polygon andrewScan(Polygon s){
    function Polygon (line 299) | Polygon convex_hull(Polygon ps){
    function diameter (line 316) | double diameter(Polygon s){
    function isConvex (line 338) | bool isConvex(Polygon p){
    function area (line 348) | double area(Polygon s){
    function area (line 356) | double area(Circle c1,Circle c2){
    function Polygon (line 373) | Polygon convexCut(Polygon p,Line l){
    function Line (line 384) | Line bisector(Point p1,Point p2){
    function Vector (line 391) | Vector translate(Vector v,double theta){
    function corner (line 398) | vector<Line> corner(Line l1,Line l2){
    function Polygon (line 422) | Polygon tangent(Circle c1,Point p2){
    function tangent (line 429) | vector<Line> tangent(Circle c1,Circle c2){
    function closest_pair (line 450) | double closest_pair(Polygon &a,int l=0,int r=-1){
    function segmentArrangement (line 474) | vector<vector<int>>
    type EndPoint (line 508) | struct EndPoint{
      method EndPoint (line 511) | EndPoint(){}
      method EndPoint (line 512) | EndPoint(Point p,int seg,int st):p(p),seg(seg),st(st){}
    function manhattan_intersection (line 519) | int manhattan_intersection(vector<Segment> ss,const int INF){
    function area (line 559) | double area(Polygon ps,Circle c){
    function istream (line 588) | istream &operator>>(istream &is,Point &p){
    function istream (line 592) | istream &operator>>(istream &is,Polygon &p){
    function istream (line 596) | istream &operator>>(istream &is,Segment &s){
    function istream (line 600) | istream &operator>>(istream &is,Circle &c){
    function ostream (line 604) | ostream &operator<<(ostream &os,Point p){
  type geometry (line 587) | namespace geometry{
    type Point (line 13) | struct Point{
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function sort_x (line 35) | bool sort_x(Point a,Point b){
    function sort_y (line 39) | bool sort_y(Point a,Point b){
    type Segment (line 46) | struct Segment{
      method Segment (line 48) | Segment(){}
      method Segment (line 49) | Segment(Point p1, Point p2):p1(p1),p2(p2){}
    type Circle (line 53) | struct Circle{
      method Circle (line 56) | Circle(){}
      method Circle (line 57) | Circle(Point c,double r):c(c),r(r){}
    function norm (line 60) | double norm(Vector a){
    function abs (line 64) | double abs(Vector a){
    function dot (line 68) | double dot(Vector a,Vector b){
    function cross (line 72) | double cross(Vector a,Vector b){
    function Point (line 76) | Point orth(Point p){return Point(-p.y,p.x);}
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function isOrthogonal (line 78) | bool isOrthogonal(Vector a,Vector b){
    function isOrthogonal (line 82) | bool isOrthogonal(Point a1,Point a2,Point b1,Point b2){
    function isOrthogonal (line 86) | bool isOrthogonal(Segment s1,Segment s2){
    function isParallel (line 90) | bool isParallel(Vector a,Vector b){
    function isParallel (line 94) | bool isParallel(Point a1,Point a2,Point b1,Point b2){
    function isParallel (line 98) | bool isParallel(Segment s1,Segment s2){
    function Point (line 102) | Point project(Segment s,Point p){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function Point (line 108) | Point reflect(Segment s,Point p){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function arg (line 112) | double arg(Vector p){
    function Vector (line 116) | Vector polar(double a,double r){
    function ccw (line 127) | int ccw(Point p0,Point p1,Point p2){
    function intersectSS (line 137) | bool intersectSS(Point p1,Point p2,Point p3,Point p4){
    function intersectSS (line 142) | bool intersectSS(Segment s1,Segment s2){
    function intersectPS (line 146) | bool intersectPS(Polygon p,Segment l){
    function getDistanceLP (line 153) | double getDistanceLP(Line l,Point p){
    function getDistanceSP (line 157) | double getDistanceSP(Segment s,Point p){
    function getDistanceSS (line 163) | double getDistanceSS(Segment s1,Segment s2){
    function intersectCC (line 176) | int intersectCC(Circle c1,Circle c2){
    function intersectSC (line 187) | bool intersectSC(Segment s,Circle c){
    function intersectCS (line 191) | int intersectCS(Circle c,Segment s){
    function Point (line 201) | Point getCrossPointSS(Segment s1,Segment s2){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function Point (line 214) | Point getCrossPointLL(Line l1,Line l2){
      method Point (line 15) | Point(){}
      method Point (line 16) | Point(double x,double y):x(x),y(y){}
      method Point (line 17) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
      method Point (line 18) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
      method Point (line 19) | Point operator*(double k){return Point(x*k,y*k);}
      method Point (line 20) | Point operator/(double k){return Point(x/k,y/k);}
      method norm (line 21) | double norm(){return x*x+y*y;}
      method abs (line 22) | double abs(){return sqrt(norm());}
    function Polygon (line 221) | Polygon getCrossPointCL(Circle c,Line l){
    function Polygon (line 235) | Polygon getCrossPointCS(Circle c,Segment s){
    function Polygon (line 247) | Polygon getCrossPointCC(Circle c1,Circle c2){
    function contains (line 258) | int contains(Polygon g,Point p){
    function Polygon (line 270) | Polygon andrewScan(Polygon s){
    function Polygon (line 299) | Polygon convex_hull(Polygon ps){
    function diameter (line 316) | double diameter(Polygon s){
    function isConvex (line 338) | bool isConvex(Polygon p){
    function area (line 348) | double area(Polygon s){
    function area (line 356) | double area(Circle c1,Circle c2){
    function Polygon (line 373) | Polygon convexCut(Polygon p,Line l){
    function Line (line 384) | Line bisector(Point p1,Point p2){
    function Vector (line 391) | Vector translate(Vector v,double theta){
    function corner (line 398) | vector<Line> corner(Line l1,Line l2){
    function Polygon (line 422) | Polygon tangent(Circle c1,Point p2){
    function tangent (line 429) | vector<Line> tangent(Circle c1,Circle c2){
    function closest_pair (line 450) | double closest_pair(Polygon &a,int l=0,int r=-1){
    function segmentArrangement (line 474) | vector<vector<int>>
    type EndPoint (line 508) | struct EndPoint{
      method EndPoint (line 511) | EndPoint(){}
      method EndPoint (line 512) | EndPoint(Point p,int seg,int st):p(p),seg(seg),st(st){}
    function manhattan_intersection (line 519) | int manhattan_intersection(vector<Segment> ss,const int INF){
    function area (line 559) | double area(Polygon ps,Circle c){
    function istream (line 588) | istream &operator>>(istream &is,Point &p){
    function istream (line 592) | istream &operator>>(istream &is,Polygon &p){
    function istream (line 596) | istream &operator>>(istream &is,Segment &s){
    function istream (line 600) | istream &operator>>(istream &is,Circle &c){
    function ostream (line 604) | ostream &operator<<(ostream &os,Point p){
  function main (line 611) | signed main(){

FILE: geometry/projectilemotion.cpp
  function projectile_motion (line 9) | vector< pair<D, D> > projectile_motion(D v,D g,D x,D y){
  function main (line 28) | signed main(){

FILE: graph/arborescence_edmond.cpp
  type Arborescence (line 12) | struct Arborescence{
    type edge (line 13) | struct edge{
      method edge (line 16) | edge(int to,T cost):to(to),cost(cost){}
    method Arborescence (line 20) | Arborescence(int n):B(n){}
    method add_edge (line 22) | void add_edge(int u,int v,T cost){
    method T (line 27) | T build(int r){
  function main (line 67) | signed main(){

FILE: graph/arborescence_tarjan.cpp
  type Arborescence (line 7) | struct Arborescence{
    type SkewHeap (line 8) | struct SkewHeap{
      method SkewHeap (line 12) | SkewHeap(T inf):INF(inf,-1),add_identity(0){}
      type Node (line 14) | struct Node{
        method Node (line 18) | Node(P val,T add):val(val),add(add){l=r=nullptr;}
      method P (line 21) | P reflect(P x,T y){return P(x.first+y,x.second);}
      method eval (line 23) | void eval(Node *a){
      method P (line 32) | P top(Node *a){
      method P (line 36) | P snd(Node *a){
      method Node (line 41) | Node* add(Node *a,T d){
        method Node (line 18) | Node(P val,T add):val(val),add(add){l=r=nullptr;}
      method Node (line 46) | Node* push(T v,int i){
        method Node (line 18) | Node(P val,T add):val(val),add(add){l=r=nullptr;}
      method Node (line 50) | Node* meld(Node *a,Node *b){
        method Node (line 18) | Node(P val,T add):val(val),add(add){l=r=nullptr;}
      method Node (line 59) | Node* pop(Node* a){
        method Node (line 18) | Node(P val,T add):val(val),add(add){l=r=nullptr;}
    type UnionFind (line 67) | struct UnionFind{
      method UnionFind (line 69) | UnionFind(int sz):r(sz,1),p(sz,0){iota(p.begin(),p.end(),0);}
      method find (line 70) | int find(int x){
      method same (line 73) | bool same(int x,int y){
      method unite (line 76) | void unite(int x,int y){
    type edge (line 84) | struct edge{
      method edge (line 87) | edge(int from,int to,T cost):from(from),to(to),cost(cost){}
    method Arborescence (line 93) | Arborescence(int n):n(n){}
    method add_edge (line 95) | void add_edge(int from,int to,T cost){
    method T (line 99) | T build(int r){
  function UVA_11183 (line 150) | signed UVA_11183(){
  function main (line 176) | signed main(){

FILE: graph/bellmanford.cpp
  type BellmanFord (line 7) | struct BellmanFord{
    type edge (line 8) | struct edge{
      method edge (line 11) | edge(int u,int v,T w):u(u),v(v),w(w){}
    method BellmanFord (line 16) | BellmanFord(int n):G(n),used(n,0),reach(n,1){}
    method add_edge (line 19) | void add_edge(int u,int v,T c){
    method build (line 24) | vector<T> build(int from,int &neg_loop){
    method dfs (line 48) | void dfs(int v){
    method T (line 54) | T shortest_path(int from,int to,int &neg_loop){
  function main (line 66) | signed main(){

FILE: graph/bfs.cpp
  function bfs (line 6) | vector<int> bfs(int s,vector< vector<int> > G){
  function main (line 25) | signed main(){

FILE: graph/bipartitedecomposition.cpp
  type BipartiteDecomposition (line 7) | struct BipartiteDecomposition{
    method BipartiteDecomposition (line 9) | BipartiteDecomposition(int n):G(n){}
    method add_edge (line 10) | void add_edge(int u,int v){
    method build (line 14) | vector<pair<int, int>> build(){
  function main (line 43) | int main(){

FILE: graph/chromatic.cpp
  function chromatic (line 6) | int chromatic(vector< vector<int> > G){

FILE: graph/cycle.cpp
  type Cycle (line 7) | struct Cycle{
    method Cycle (line 10) | Cycle(int n_):used(n_,0),G(n_){}
    method add_edge (line 12) | void add_edge(int u,int v){
    method dfs (line 18) | int dfs(int v,int p){
    method build (line 33) | vector<int> build(){
  function main (line 49) | signed main(){

FILE: graph/dijkstra.cpp
  type Dijkstra (line 7) | struct Dijkstra{
    type Edge (line 8) | struct Edge{
      method Edge (line 11) | Edge(int to,T cost):to(to),cost(cost){}
    method Dijkstra (line 18) | Dijkstra(int n):G(n){}
    method add_edge (line 20) | void add_edge(int u,int v,T c){
    method build (line 24) | void build(int s){
    method T (line 47) | T operator[](int k){return ds[k];}
    method restore (line 49) | vector<int> restore(int to){
  function main (line 59) | signed main(){

FILE: graph/dominatortree.cpp
  type DominatorTree (line 6) | struct DominatorTree{
    type UnionFind (line 7) | struct UnionFind{
      method UnionFind (line 10) | UnionFind(vector<int> &semi):
      method find (line 15) | int find(int v){
      method eval (line 21) | int eval(int v){
      method link (line 25) | void link(int p,int v){ps[v]=p;}
    method DominatorTree (line 30) | DominatorTree(int n):
    method add_edge (line 35) | void add_edge(int u,int v){
    method dfs (line 40) | void dfs(int v){
    method build (line 50) | void build(int rt){
  function main (line 88) | int main(){

FILE: graph/dynamicconnectivity.cpp
  type PersistentUnionFind (line 6) | struct PersistentUnionFind{
    method PersistentUnionFind (line 10) | PersistentUnionFind(int n):
    method find (line 12) | int find(int x){
    method same (line 15) | bool same(int x,int y){
    method unite (line 18) | void unite(int x,int y){
    method undo (line 27) | void undo(int t=1){
  type DynamicConnectivity (line 38) | struct DynamicConnectivity{
    method DynamicConnectivity (line 48) | DynamicConnectivity(int n,int q_):q(1),puf(n){
    method insert (line 53) | void insert(int t,int u,int v){
    method erase (line 58) | void erase(int t,int u,int v){
    method add (line 63) | void add(int a,int b,edge e,int k,int l,int r){
    method add (line 74) | void add(range r,edge e){
    method build (line 78) | void build(){
    method exec (line 88) | void exec(const F &f,int k=1){
  function main (line 104) | signed main(){

FILE: graph/girth.cpp
  function girth (line 5) | int girth(vector< vector<int> > G){
  function CFR580_B (line 36) | signed CFR580_B(){
  function main (line 74) | signed main(){

FILE: graph/grid.cpp
  type Grid (line 7) | struct Grid{
    method Grid (line 10) | Grid(int h_,int w_,F f_):h(h_),w(w_),f(f_){}
    method idx (line 11) | int idx(int y,int x){return y*w+x;}
    method T (line 13) | T operator[](int k){return f(k/w,k%w);}
    method edges (line 14) | decltype(auto) edges(){
  function main (line 28) | signed main(){

FILE: graph/independentset.cpp
  type IndependentSet (line 6) | struct IndependentSet{
    method IndependentSet (line 11) | IndependentSet(int n):
    method add_edge (line 14) | void add_edge(int u,int v){
    method dfs (line 20) | void dfs(){
    method build (line 64) | int build(){
  function main (line 76) | signed main(){

FILE: graph/kruskal.cpp
  type Kruskal (line 12) | struct Kruskal : UnionFind{
    type Edge (line 14) | struct Edge{
      method Edge (line 18) | Edge(int src,int dst,T cost):
    method add_edge (line 26) | void add_edge(int u,int v,T c){
    method T (line 30) | T build(){
  function main (line 44) | int main(){

FILE: graph/lowlink.cpp
  type LowLink (line 6) | struct LowLink{
    method LowLink (line 15) | LowLink(int n):n(n),pos(0),ord(n,-1),low(n),
    method add_edge (line 18) | void add_edge(int u,int v){
    method is_bridge (line 23) | bool is_bridge(int u,int v){
    method dfs (line 28) | void dfs(int v){
    method fill_component (line 60) | void fill_component(int v){
    method add_component (line 69) | void add_component(int v,int &k){
    method build (line 76) | int build(){
  function ARC045_D (line 118) | signed ARC045_D(){
  function ARC062_F (line 189) | signed ARC062_F(){
  function main (line 253) | signed main(){

FILE: graph/manhattanmst.cpp
  function manhattanmst (line 7) | vector<pair<int, int>> manhattanmst(vector<T> xs,vector<T> ys){
  function main (line 42) | signed main(){

FILE: graph/multipleeuleriantrail.cpp
  function hasMultipleEulerianTrail (line 8) | bool hasMultipleEulerianTrail(Graph &G){

FILE: graph/nicetree.cpp
  type NiceTree (line 6) | struct NiceTree{
    method NiceTree (line 10) | NiceTree(int n):G(n),ex(n),buff(n){}
    method add_edge (line 12) | void add_edge(int u,int v){
    type Type (line 20) | enum Type{LEAF, JOIN, INTRODUCE, FORGET}
    type Node (line 21) | struct Node{
      method Node (line 23) | Node():type(-1),is_root(1){}
      method add_vertex (line 27) | void add_vertex(int v){bag.emplace_back(v);}
      method add_child (line 31) | void add_child(int v){child.emplace_back(v);}
    method to_nice (line 35) | void to_nice(){
    method build (line 119) | void build(){
    method dfs (line 190) | void dfs(int v,F1 &leaf,F2 &join,F3 &introduce,F4 &forget){
  function CSA_SPECIAL_MVC (line 230) | signed CSA_SPECIAL_MVC(){
  function main (line 331) | signed main(){

FILE: graph/rangetorange.cpp
  type RangeToRange (line 8) | struct RangeToRange{
    method RangeToRange (line 11) | RangeToRange(int n):n(n),ptr(3*n){}
    method add_edge (line 18) | void add_edge(int u,int v,F f){
    method init (line 24) | void init(F f){
    method add_edge (line 37) | void add_edge(int l1,int r1,int l2,int r2,F f,G g){
    method idx (line 48) | int idx(int v)const{return 1*n+v;}
    method size (line 49) | size_t size()const{return ptr;}
  function main (line 54) | signed main(){

FILE: graph/semikernel.cpp
  type SemiKernel (line 5) | struct SemiKernel{
    method SemiKernel (line 9) | SemiKernel(int n):n(n),G(n),R(n),used(n,0),dp(n){}
    method add_edge (line 11) | void add_edge(int u,int v){
    method dfs (line 16) | void dfs(int v){
    method build (line 30) | vector<int> build(){
  function CFR503_C (line 38) | signed CFR503_C(){
  function main (line 65) | signed main(){

FILE: graph/stronglyconnectedcomponent.cpp
  type SCC (line 6) | struct SCC{
    method SCC (line 9) | SCC(int n):G(n),R(n),used(n),blg(n){}
    method add_edge (line 11) | void add_edge(int u,int v){
    method dfs (line 16) | void dfs(int v){
    method rdfs (line 23) | void rdfs(int v,int k){
    method build (line 31) | int build(bool uniq=true){
  function main (line 64) | signed main(){

FILE: graph/topologicalsort.cpp
  type TopologicalSort (line 6) | struct TopologicalSort{
    method TopologicalSort (line 9) | TopologicalSort(int n):G(n),indeg(n,0){}
    method add_edge (line 11) | void add_edge(int s,int t){
    method build (line 16) | vector<int> build(){

FILE: graph/triangle.cpp
  type Triangle (line 6) | struct Triangle{
    method Triangle (line 9) | Triangle(int n):G(n){}
    method add_edge (line 11) | void add_edge(int u,int v){
    method build (line 17) | void build(F f){
  function main (line 43) | signed main(){

FILE: graph/twoedgeconnectedcomponents.cpp
  type TwoEdgeConnectedComponents (line 7) | struct TwoEdgeConnectedComponents{
    method TwoEdgeConnectedComponents (line 11) | TwoEdgeConnectedComponents(int n):
    method add_edge (line 14) | void add_edge(int u,int v){
    method is_bridge (line 20) | bool is_bridge(int u,int v){
    method dfs (line 25) | void dfs(int v,int &pos){
    method fill_component (line 44) | void fill_component(int v){
    method add_component (line 53) | void add_component(int v,int &k){
    method build (line 60) | int build(){
    method forest (line 73) | vector<vector<int>> forest(){
  function main (line 86) | signed main(){

FILE: graph/twosatisfiability.cpp
  type TwoSat (line 11) | struct TwoSat{
    method TwoSat (line 14) | TwoSat(int n):n(n),scc(n*2){}
    method negate (line 15) | int negate(int v){return (n+v)%(n*2);}
    method add_if (line 16) | void add_if(int u,int v){
    method add_or (line 21) | void add_or(int u,int v){
    method add_nand (line 25) | void add_nand(int u,int v){
    method set_true (line 29) | void set_true(int v){
    method set_false (line 33) | void set_false(int v){
    method build (line 37) | vector<int> build(){
  function CFR441_C (line 51) | signed CFR441_C(){
  function YUKI_470 (line 111) | signed YUKI_470(){
  function main (line 161) | signed main(){

FILE: graph/voronoiminimumspanningtree.cpp
  type VoronoiMST (line 7) | struct VoronoiMST{
    method VoronoiMST (line 12) | VoronoiMST(vector<T> &x){
    method add_edge (line 17) | void add_edge(int u,int v,T c){
    method build (line 21) | vector<vector<E> > build(){
  function CF17FINAL_J (line 67) | signed CF17FINAL_J(){
  function main (line 99) | signed main(){

FILE: heuristic/timer.cpp
  type Timer (line 19) | struct Timer {
    method Timer (line 21) | Timer(){reset();}
    method reset (line 22) | void reset(){start=getCycle();}
    method get (line 23) | inline double get(){return (double)(getCycle()-start)/CYCLES_PER_SEC;}
    method i64 (line 24) | inline i64 getCycle(){
  function nxt (line 35) | void nxt(){
  function main (line 42) | signed main(){

FILE: heuristic/xorshift.cpp
  function xor128 (line 9) | uint32_t xor128(){
  function main (line 20) | signed main(){

FILE: io/precision.cpp
  type Precision (line 6) | struct Precision{
    method Precision (line 7) | Precision(){
  function main (line 13) | signed main(){

FILE: io/single.cpp
  function read (line 8) | vector<T> read(size_t n){
  function main (line 15) | signed main(){

FILE: io/space.cpp
  function space (line 8) | void space(const vector<T> &vs){
  function main (line 17) | signed main(){

FILE: io/tuple.cpp
  function read_tuple_impl (line 7) | void read_tuple_impl(TV&) {}
  function read_tuple_impl (line 9) | void read_tuple_impl(TV& ts) {
  function read_tuple (line 13) | decltype(auto) read_tuple(size_t n) {
  function main (line 21) | signed main(){

FILE: io/yesno.cpp
  type BoolPrinter (line 7) | struct BoolPrinter{
    method BoolPrinter (line 9) | BoolPrinter(string a_,string b_):a(a_),b(b_){}
    method string (line 10) | string operator[](int k){return k?a:b;}
  function main (line 17) | signed main(){

FILE: leetcode/treenode.cpp
  type TreeNode (line 10) | struct TreeNode {
    method TreeNode (line 14) | TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  function dfs (line 17) | int dfs(TreeNode* v,int &k,vector<vector<int> > &G,vector<int> &x){
  function build (line 35) | void build(TreeNode* v,vector<vector<int> > &G,vector<int> &x){
  function main (line 44) | signed main(){

FILE: linearalgebra/binarymatrix.cpp
  function gauss (line 10) | void gauss(mat &v){
  function mrank (line 24) | int mrank(mat v,int m){
  function mat (line 50) | mat mul(const mat &a,const mat &b){
  function mat (line 66) | mat mat_pow(mat v,long long k){
  function CFR382_D (line 85) | signed CFR382_D(){
  function ARC054_D (line 107) | signed ARC054_D(){
  function main (line 127) | signed main(){

FILE: linearalgebra/matrix.cpp
  type Matrix (line 7) | struct Matrix{
    method Matrix (line 12) | Matrix(size_t r,size_t c):dat(r,arr(c,K())){}
    method Matrix (line 13) | Matrix(mat dat):dat(dat){}
    method size (line 15) | size_t size() const{return dat.size();}
    method empty (line 16) | bool empty() const{return size()==0;}
    method arr (line 17) | arr& operator[](size_t k){return dat[k];}
    method arr (line 18) | const arr& operator[](size_t k) const {return dat[k];}
    method Matrix (line 20) | static Matrix matmul(const Matrix &A,const Matrix &B){
    method Matrix (line 29) | static Matrix identity(size_t n){
    method Matrix (line 35) | Matrix pow(long long n) const{
    method is_zero (line 53) | static bool is_zero(T x){return abs(x)<1e-8;}
    method is_zero (line 55) | static bool is_zero(T x){return x==T(0);}
    method compare (line 58) | static bool compare(T x,T y){return abs(x)<abs(y);}
    method compare (line 60) | static bool compare(T,T y){return !is_zero(y);}
    method Matrix (line 63) | static Matrix gauss_jordan(const Matrix &A,const Matrix &B){
    method Matrix (line 92) | Matrix inv() const{
    method arr (line 97) | static arr linear_equations(const Matrix &A,const arr &b){
    method K (line 106) | K determinant() const{
  function SPOJ_MIFF (line 132) | signed SPOJ_MIFF(){
  function SPOJ_MPOW (line 165) | signed SPOJ_MPOW(){
  function main (line 194) | signed main(){

FILE: linearalgebra/squarematrix.cpp
  type SquareMatrix (line 7) | struct SquareMatrix{
    method SquareMatrix (line 12) | SquareMatrix(){
    method size (line 22) | size_t size() const{return N;}
    method arr (line 23) | arr& operator[](size_t k){return dat[k];}
    method arr (line 24) | const arr& operator[](size_t k) const {return dat[k];}
    method SquareMatrix (line 26) | static SquareMatrix add_identity(){return SquareMatrix();}
    method SquareMatrix (line 27) | static SquareMatrix mul_identity(){
    method SquareMatrix (line 33) | SquareMatrix operator*(const SquareMatrix &B) const{
    method SquareMatrix (line 42) | SquareMatrix operator+(const SquareMatrix &B) const{
    method SquareMatrix (line 50) | SquareMatrix pow(long long n) const{
  function main (line 63) | signed main(){

FILE: linearalgebra/tree_theorem.cpp
  type MatrixTreeTheorem (line 13) | struct MatrixTreeTheorem{
    type edge (line 15) | struct edge{
      method edge (line 18) | edge(int a,int b,T c):a(a),b(b),c(c){}
    method MatrixTreeTheorem (line 29) | MatrixTreeTheorem(int n):used(n),H(n),uf(n){}
    method add_edge (line 31) | void add_edge(int a,int b,T c){
    method bfs (line 35) | vector<int> bfs(int v){
    method build (line 52) | tuple<int, K, T> build(){
  function ARC018_D (line 112) | signed ARC018_D(){
  function main (line 132) | signed main(){

FILE: linkcuttree/base.cpp
  type LinkCutTreeBase (line 7) | struct LinkCutTreeBase{
    method Node (line 13) | inline Node* create(Args&&... args){
    method idx (line 17) | inline size_t idx(Node *t){return t-ptr;}
    method Node (line 18) | Node* operator[](size_t k){return ptr+k;}
    method toggle (line 20) | inline void toggle(Node *t){
    method Node (line 24) | inline Node* eval(Node *t){
    method pushup (line 28) | inline void pushup(Node *t){
    method Node (line 32) | inline Node* expose(Node *t){
    method rotR (line 36) | void rotR(Node *t){
    method rotL (line 48) | void rotL(Node *t){
    method is_root (line 61) | bool is_root(Node *t){
    method splay (line 65) | void splay(Node *t){
    method link (line 88) | void link(Node *par,Node *c){
    method cut (line 96) | void cut(Node *c){
    method evert (line 104) | void evert(Node *t){
    method Node (line 110) | Node *parent(Node *t){
    method Node (line 119) | Node *root(Node *t){
    method is_connected (line 126) | bool is_connected(Node *a,Node *b){
    method Node (line 130) | Node *lca(Node *a,Node *b){
  function main (line 138) | signed main(){

FILE: linkcuttree/farthest.cpp
  type NodeBase (line 13) | struct NodeBase{
    method NodeBase (line 19) | NodeBase(T val):rev(0),val(val){
  type Farthest (line 27) | struct Farthest : LinkCutTreeBase<Np, LIM, Farthest<Np, LIM>>{
    method Node (line 32) | Node* create(T val){
    method toggle (line 36) | inline void toggle(Node *t){
    method Node (line 42) | inline Node* eval(Node *t){
    method pushup (line 51) | inline void pushup(Node *t){
    method Node (line 72) | inline Node* expose(Node *t){
  function TKPPC2015_J (line 89) | signed TKPPC2015_J(){
  function main (line 138) | signed main(){

FILE: linkcuttree/path.cpp
  type NodeBase (line 13) | struct NodeBase{
    method NodeBase (line 20) | NodeBase(T val,E laz):
  type Path (line 26) | struct Path : LinkCutTreeBase<Np, LIM, Path<Np, LIM>>{
    method Path (line 42) | Path(F f,G g,H h,S flip,E ei):
    method Path (line 45) | Path(F f,G g,H h,E ei):
    method Node (line 48) | Node* create(T val){
    method propagate (line 52) | inline void propagate(Node *t,E v){
    method toggle (line 58) | inline void toggle(Node *t){
    method Node (line 64) | inline Node* eval(Node *t){
    method pushup (line 78) | inline void pushup(Node *t){
    method Node (line 86) | inline Node* expose(Node *t){
    method T (line 98) | T query(Node *t){
    method update (line 103) | void update(Node *t,E v){
    method set_val (line 109) | void set_val(Node *t,T v){
  function SPOJ_DYNACON1 (line 119) | signed SPOJ_DYNACON1(){
  function main (line 157) | signed main(){

FILE: linkcuttree/subtree.cpp
  type NodeBase (line 13) | struct NodeBase{
    method NodeBase (line 18) | NodeBase(A val,A dat,A sum):
  type Subtree (line 24) | struct Subtree : LinkCutTreeBase<Np, LIM, Subtree<Np, LIM>>{
    method Node (line 29) | Node* create(A val){
    method toggle (line 33) | inline void toggle(Node *t){
    method Node (line 38) | inline Node* eval(Node *t){
    method A (line 47) | inline A resolve(Node *t){
    method pushup (line 51) | inline void pushup(Node *t){
    method Node (line 60) | inline Node* expose(Node *t){
    method A (line 74) | A query(Node *t){
    method set_val (line 79) | void set_val(Node *t,A a){
  function CFR564_E (line 95) | signed CFR564_E(){
  function NIKKEI2019_QUAL_E (line 221) | signed NIKKEI2019_QUAL_E(){
  function main (line 278) | signed main(){

FILE: matching/bipartite.cpp
  type Bipartite (line 7) | struct Bipartite{
    method Bipartite (line 12) | Bipartite(int n):
    method add_edge (line 15) | void add_edge(int u,int v){
    method dfs (line 20) | int dfs(int v){
    method build (line 34) | int build(){
    method disable (line 44) | int disable(int v){
    method enable (line 54) | int enable(int v){
    method cut_edge (line 61) | int cut_edge(int u,int v){
  function main (line 75) | signed main(){

FILE: matching/hopcroft_karp.cpp
  type HopcroftKarp (line 7) | struct HopcroftKarp{
    method HopcroftKarp (line 12) | HopcroftKarp(int L,int R):
    method add_edge (line 15) | void add_edge(int u,int v){
    method bfs (line 20) | bool bfs(){
    method dfs (line 47) | bool dfs(int v){
    method build (line 63) | int build(){
  function main (line 76) | signed main(){

FILE: matching/tutte.cpp
  function maximal_matching (line 11) | int maximal_matching(vector< vector<int> > G){
  function main (line 52) | signed main(){

FILE: math/affine.cpp
  type Affine (line 6) | namespace Affine{
    function T (line 8) | T op(T a,T b){return T(a.first+b.first,a.second+b.second);}
    function T (line 10) | T mapping(T a,E b){return T(a.first*b.first+a.second*b.second,a.second);}
    function E (line 12) | E composition(E a,E b){return E(a.first*b.first,a.second*b.first+b.sec...
    function T (line 14) | T e(){return T(0,0);}
    function E (line 15) | E id(){return E(1,0);}
    function params (line 18) | decltype(auto) params(){
  function main (line 28) | signed main(){

FILE: math/bostanmori.cpp
  type BostanMori (line 10) | struct BostanMori{
    method BostanMori (line 15) | BostanMori(Conv conv_):conv(conv_){}
    method Poly (line 17) | Poly sub(Poly as,int odd){
    method T (line 25) | T build(long long k,Poly as,Poly cs){
  function main (line 45) | signed main(){

FILE: math/carmichael.cpp
  function T (line 8) | T carmichael_lambda(T n){
  function main (line 24) | signed main(){

FILE: math/combination.cpp
  type Combination (line 13) | struct Combination{
    method Combination (line 18) | Combination(T mod):mod(mod){init();}
    method init (line 20) | void init(){
    method T (line 26) | T mod_fact(T n,T& e){
    method T (line 35) | T mod_comb(T n,T k){
  function main (line 46) | signed main(){

FILE: math/convertbase.cpp
  function convert_base (line 7) | vector<T> convert_base(T x,T b){
  function main (line 24) | signed main(){

FILE: math/dual.cpp
  type Dual (line 7) | struct Dual{
    method Dual (line 9) | Dual(T v=T()):v(v){}
    method Dual (line 10) | Dual operator+(const Dual &o)const{return Dual(o.v+v);}
    method Dual (line 11) | Dual operator*(const Dual &o)const{return Dual(o.v*v);}
  function main (line 16) | signed main(){

FILE: math/enumerate_primes.cpp
  function enumerate_primes (line 7) | vector<int> enumerate_primes(int n){
  function main (line 23) | signed main(){

FILE: math/extgcd.cpp
  function T (line 10) | T extgcd(T a,T b,T& x,T& y){
  function extgcd (line 21) | pair<T, T> extgcd(T a,T b){
  function main (line 29) | signed main(){

FILE: math/factorize.cpp
  function factorize (line 7) | map<T, int> factorize(T x){
  function main (line 21) | signed main(){

FILE: math/fraction.cpp
  function fraction (line 9) | fraction(T n,T d):num(n),den(d){
  function fraction (line 16) | const fraction operator+(const fraction& a) const{
  function fraction (line 19) | const fraction operator-(const fraction& a) const{
  function fraction (line 22) | const fraction operator*(const fraction& a) const{
  function fraction (line 25) | const fraction operator/(const fraction& a) const{
  function fraction (line 28) | const fraction operator*(T k) const{return fraction(num*k,den);}
  function fraction (line 29) | const fraction operator/(T k) const{return fraction(num,den*k);}
  function define_cmp (line 32) | define_cmp(==)

FILE: math/isprime.cpp
  function isprime (line 7) | int isprime(T x){
  function main (line 15) | signed main(){

FILE: math/kitamasa.cpp
  type Kitamasa (line 7) | struct Kitamasa{
    method Kitamasa (line 13) | Kitamasa(const VR &C)
    method VR (line 19) | VR merge(const VR &xs,const VR &ys){
    method R (line 31) | R calc(const VR &A,long long n){
  function ABC009_D (line 48) | signed ABC009_D(){
  function main (line 75) | signed main(){

FILE: math/linearcongruence.cpp
  function linear_congruence (line 13) | pair<T, T> linear_congruence(const vector<T> &A,
  function main (line 29) | signed main(){

FILE: math/linearfunction.cpp
  type LinearFunction (line 8) | struct LinearFunction{
    method LinearFunction (line 10) | LinearFunction():a(0),b(0){}
    method LinearFunction (line 11) | LinearFunction(T a,T b):a(a),b(b){}
    method LF (line 14) | static LF add_identity(){return LF(T(0),T(0));}
    method LF (line 15) | static LF mul_identity(){return LF(T(1),T(0));}
    method LF (line 16) | LF& operator+=(const LF &o){
    method LF (line 20) | LF& operator*=(const LF &o){
    method LF (line 25) | LF operator+(const LF &o)const{return LF(*this)+=o;}
    method LF (line 26) | LF operator*(const LF &o)const{return LF(*this)*=o;}
    method T (line 28) | T operator()(T x) const{return a*x+b;}
  function main (line 33) | signed main(){

FILE: math/moebius.cpp
  function moebius (line 7) | vector<int> moebius(int n){
  function main (line 27) | signed main(){

FILE: math/quotients.cpp
  function quotients (line 8) | decltype(auto) quotients(T n){
  function main (line 22) | signed main(){

FILE: math/sum_of_floor.cpp
  function T (line 9) | T sum_of_floor(T n,T m,T a,T b){
  function main (line 29) | signed main(){

FILE: math/sum_of_geometric_sequence.cpp
  function sum_of_geometric_sequence_impl (line 9) | pair<T, T> sum_of_geometric_sequence_impl(T r,long long n){
  function T (line 19) | T sum_of_geometric_sequence(T r,long long n){
  function main (line 25) | signed main(){

FILE: math/tetrahedra.cpp
  function isTriangle (line 11) | bool isTriangle(double a1,double a2,double a3){
  function tetrahedra (line 16) | double tetrahedra(double OA,double OB,double OC,
  function main (line 34) | signed main(){

FILE: math/totient.cpp
  function T (line 7) | T totient(T n){
  function main (line 19) | signed main(){

FILE: math/totient_table.cpp
  function totient_table (line 6) | vector<int> totient_table(int n){
  function main (line 18) | signed main(){

FILE: math/twoway.cpp
  type TwoWay (line 7) | struct TwoWay{
    method TwoWay (line 9) | TwoWay(T z=T()):x(z),y(z){}
    method TwoWay (line 10) | TwoWay(T x,T y):x(x),y(y){}
    method TwoWay (line 11) | TwoWay operator+(const TwoWay &o)const{return TwoWay(x+o.x,o.y+y);}
    method TwoWay (line 12) | TwoWay operator*(const TwoWay &o)const{return TwoWay(x*o.x,o.y*y);}
  function main (line 17) | signed main(){

FILE: maxflow/dinic.cpp
  type Dinic (line 9) | struct Dinic{
    type Edge (line 10) | struct Edge {
      method Edge (line 14) | Edge(int dst,Flow cap,int rev):dst(dst),cap(cap),rev(rev){}
    method Dinic (line 20) | Dinic(int n):G(n),level(n),iter(n){}
    method add_edge (line 22) | int add_edge(int src,int dst,Flow cap){
    method bfs (line 30) | void bfs(int s){
    method Flow (line 46) | Flow dfs(int v,int t,Flow f){
    method Flow (line 61) | Flow flow(int s,int t,Flow lim){
    method Flow (line 78) | Flow flow(int s,int t){
    method Flow (line 82) | Flow cut(int s,int t,int x,int a){
    method Flow (line 95) | Flow link(int s,int t,int x,int a,Flow f){
  function main (line 104) | signed main(){

FILE: maxflow/fordfulkerson.cpp
  type FordFulkerson (line 8) | struct FordFulkerson{
    type Edge (line 9) | struct Edge{
      method Edge (line 13) | Edge(int dst,Flow cap,int rev):dst(dst),cap(cap),rev(rev){}
    method FordFulkerson (line 19) | FordFulkerson(int n):G(n),used(n){}
    method add_edge (line 21) | int add_edge(int src,int dst,Flow cap){
    method Flow (line 29) | Flow dfs(int v,int t,Flow f){
    method Flow (line 43) | Flow flow(int s,int t,Flow lim){
    method Flow (line 55) | Flow flow(int s,int t){
  function main (line 61) | signed main(){

FILE: maxflow/leastflow.cpp
  type LeastFlow (line 12) | struct LeastFlow{
    method LeastFlow (line 16) | LeastFlow(int n):G(n+2),X(n),Y(n+1),sum(0){}
    method add_edge (line 18) | void add_edge(int from,int to,T low,T hgh){
    method T (line 26) | T flow(int s,int t){
  function main (line 36) | signed main(){

FILE: maxflow/twocommodity.cpp
  type TwoCommodity (line 12) | struct TwoCommodity{
    method TwoCommodity (line 15) | TwoCommodity(int n):G(n+2),H(n+2),S(n),T(n+1){}
    method add_edge (line 17) | void add_edge(int src,int dst,Flow cap){
    method Flow (line 23) | Flow build(int s,int t,int u,int v){
  function main (line 42) | signed main(){

FILE: mincostflow/negativeedge.cpp
  type NegativeEdge (line 13) | struct NegativeEdge{
    method NegativeEdge (line 18) | NegativeEdge(int n):G(n+2),fs(n+2,0),sum(0),S(n),T(n+1){}
    method use_edge (line 20) | void use_edge(int u,int v,Flow cap,Cost cost){
    method add_edge (line 26) | void add_edge(int u,int v,Flow cap,Cost cost){
    method build (line 35) | bool build(){
    method build (line 49) | bool build(int ts,int tt,Flow tf){
    method Cost (line 55) | Cost get_cost(){
  function main (line 62) | signed main(){

FILE: mincostflow/primaldual.cpp
  type PrimalDual (line 8) | struct PrimalDual{
    type Edge (line 9) | struct Edge{
      method Edge (line 14) | Edge(int dst,Flow cap,Cost cost,int rev):
    method PrimalDual (line 22) | PrimalDual(int n):G(n),h(n),dist(n),prevv(n),preve(n){}
    method add_edge (line 24) | void add_edge(int u,int v,Flow cap,Cost cost){
    method Cost (line 31) | Cost residual_cost(int src,Edge &e){
    method dijkstra (line 35) | void dijkstra(int s){
    method build (line 64) | bool build(int s,int t,Flow f,
    method Cost (line 94) | Cost get_cost(){return res;}
  function main (line 99) | signed main(){

FILE: mod/factorial.cpp
  function factorial (line 15) | int factorial(long long n,const int MOD){
  function main (line 87) | signed main(){

FILE: mod/inverse.cpp
  function T (line 13) | T mod_inverse(T a,const T MOD){
  function main (line 21) | signed main(){

FILE: mod/log.cpp
  function T (line 10) | T mod_log(T a,T b,const T MOD){
  function main (line 58) | signed main(){

FILE: mod/mint.cpp
  type Mint (line 8) | struct Mint{
    method Mint (line 11) | Mint():v(0){}
    method Mint (line 12) | Mint(signed v):v(v){}
    method Mint (line 13) | Mint(long long t){v=t%MOD;if(v<0) v+=MOD;}
    method Mint (line 15) | Mint pow(long long k){
    method Mint (line 25) | static Mint add_identity(){return Mint(0);}
    method Mint (line 26) | static Mint mul_identity(){return Mint(1);}
    method Mint (line 28) | Mint inv(){return pow(MOD-2);}
    method Mint (line 30) | Mint& operator+=(Mint a){v+=a.v;if(v>=MOD)v-=MOD;return *this;}
    method Mint (line 31) | Mint& operator-=(Mint a){v+=MOD-a.v;if(v>=MOD)v-=MOD;return *this;}
    method Mint (line 32) | Mint& operator*=(Mint a){v=1LL*v*a.v%MOD;return *this;}
    method Mint (line 33) | Mint& operator/=(Mint a){return (*this)*=a.inv();}
    method Mint (line 35) | Mint operator+(Mint a) const{return Mint(v)+=a;}
    method Mint (line 36) | Mint operator-(Mint a) const{return Mint(v)-=a;}
    method Mint (line 37) | Mint operator*(Mint a) const{return Mint(v)*=a;}
    method Mint (line 38) | Mint operator/(Mint a) const{return Mint(v)/=a;}
    method Mint (line 40) | Mint operator+() const{return *this;}
    method Mint (line 41) | Mint operator-() const{return v?Mint(MOD-v):Mint(v);}
    method Mint (line 46) | static Mint comb(long long n,int k){
  function ostream (line 56) | ostream& operator<<(ostream &os,Mint<T, MOD> m){os<<m.v;return os;}
  function main (line 59) | signed main(){

FILE: mod/montmort.cpp
  type Montmort (line 8) | struct Montmort{
    method Montmort (line 13) | Montmort(int n,const int MOD):dp(n+1,0){
    method T (line 22) | T operator[](int n){return dp[n];}
  function main (line 26) | signed main(){

FILE: mod/order.cpp
  function T (line 13) | T order(T x,const T MOD){
  function main (line 48) | signed main(){

FILE: mod/pow.cpp
  function T (line 8) | T mod_pow(T a,long long n,const T MOD){
  function main (line 21) | signed main(){

FILE: mod/rint.cpp
  type Rint (line 7) | struct Rint{
    method set_mod (line 9) | static void set_mod(T nmod){mod=nmod;}
    method Rint (line 12) | Rint():v(0){}
    method Rint (line 13) | Rint(signed v):v(v){}
    method Rint (line 14) | Rint(long long t){v=t%mod;if(v<0) v+=mod;}
    method Rint (line 16) | Rint pow(long long k){
    method Rint (line 26) | static Rint add_identity(){return Rint(0);}
    method Rint (line 27) | static Rint mul_identity(){return Rint(1);}
    method Rint (line 29) | Rint inv(){return pow(mod-2);}
    method Rint (line 31) | Rint& operator+=(Rint a){v+=a.v;if(v>=mod)v-=mod;return *this;}
    method Rint (line 32) | Rint& operator-=(Rint a){v+=mod-a.v;if(v>=mod)v-=mod;return *this;}
    method Rint (line 33) | Rint& operator*=(Rint a){v=1LL*v*a.v%mod;return *this;}
    method Rint (line 34) | Rint& operator/=(Rint a){return (*this)*=a.inv();}
    method Rint (line 36) | Rint operator+(Rint a) const{return Rint(v)+=a;}
    method Rint (line 37) | Rint operator-(Rint a) const{return Rint(v)-=a;}
    method Rint (line 38) | Rint operator*(Rint a) const{return Rint(v)*=a;}
    method Rint (line 39) | Rint operator/(Rint a) const{return Rint(v)/=a;}
    method Rint (line 41) | Rint operator-() const{return v?Rint(mod-v):Rint(v);}
  function ostream (line 48) | ostream& operator<<(ostream &os,Rint<T> m){os<<m.v;return os;}
  function main (line 51) | signed main(){

FILE: mod/sqrt.cpp
  function jacobi (line 7) | int jacobi(T a,T m){
  function mod_sqrt (line 24) | vector<T> mod_sqrt(T a,const T MOD){
  function main (line 57) | signed main(){

FILE: mod/tetration.cpp
  function T (line 12) | T mpow(T a,T n,T m,T &f){
  function T (line 32) | T tetration(T a,T n,const T MOD,T &f){
  function T (line 47) | T tetration(T a,T n,const T MOD){
  function main (line 55) | signed main(){

FILE: polynomial/berlekampmassey.cpp
  function berlekamp_massey (line 9) | vector<T> berlekamp_massey(vector<T> &as){
  function main (line 38) | signed main(){

FILE: polynomial/hash.cpp
  type PolynomialHash (line 12) | struct PolynomialHash{
    type V (line 13) | struct V{
      method V (line 17) | V(int x):v1(x),v2(x),v3(x){}
      method V (line 18) | V(long long x):v1(x),v2(x),v3(x){}
      method V (line 19) | V(M1 v1,M2 v2,M3 v3):v1(v1),v2(v2),v3(v3){}
      method V (line 21) | V& operator+=(V a){v1+=a.v1;v2+=a.v2;v3+=a.v3;;return *this;}
      method V (line 22) | V& operator-=(V a){v1-=a.v1;v2-=a.v2;v3-=a.v3;;return *this;}
      method V (line 23) | V& operator*=(V a){v1*=a.v1;v2*=a.v2;v3*=a.v3;;return *this;}
      method V (line 24) | V& operator/=(V a){v1/=a.v1;v2/=a.v2;v3/=a.v3;;return *this;}
      method V (line 26) | V operator+(V a) const{return V(*this)+=a;}
      method V (line 27) | V operator-(V a) const{return V(*this)-=a;}
      method V (line 28) | V operator*(V a) const{return V(*this)*=a;}
      method V (line 29) | V operator/(V a) const{return V(*this)/=a;}
      method norm (line 31) | tuple<M1, M2, M3> norm() const{return make_tuple(v1,v2,v3);}
    method init (line 44) | void init(int n,vector<M>& po,vector<M>& op){
    method PolynomialHash (line 53) | PolynomialHash(size_t n){
    method V (line 59) | V build(const vector<T> &v){
      method V (line 17) | V(int x):v1(x),v2(x),v3(x){}
      method V (line 18) | V(long long x):v1(x),v2(x),v3(x){}
      method V (line 19) | V(M1 v1,M2 v2,M3 v3):v1(v1),v2(v2),v3(v3){}
      method V (line 21) | V& operator+=(V a){v1+=a.v1;v2+=a.v2;v3+=a.v3;;return *this;}
      method V (line 22) | V& operator-=(V a){v1-=a.v1;v2-=a.v2;v3-=a.v3;;return *this;}
      method V (line 23) | V& operator*=(V a){v1*=a.v1;v2*=a.v2;v3*=a.v3;;return *this;}
      method V (line 24) | V& operator/=(V a){v1/=a.v1;v2/=a.v2;v3/=a.v3;;return *this;}
      method V (line 26) | V operator+(V a) const{return V(*this)+=a;}
      method V (line 27) | V operator-(V a) const{return V(*this)-=a;}
      method V (line 28) | V operator*(V a) const{return V(*this)*=a;}
      method V (line 29) | V operator/(V a) const{return V(*this)/=a;}
      method norm (line 31) | tuple<M1, M2, M3> norm() const{return make_tuple(v1,v2,v3);}
    method V (line 70) | V term(size_t x,T k){
      method V (line 17) | V(int x):v1(x),v2(x),v3(x){}
      method V (line 18) | V(long long x):v1(x),v2(x),v3(x){}
      method V (line 19) | V(M1 v1,M2 v2,M3 v3):v1(v1),v2(v2),v3(v3){}
      method V (line 21) | V& operator+=(V a){v1+=a.v1;v2+=a.v2;v3+=a.v3;;return *this;}
      method V (line 22) | V& operator-=(V a){v1-=a.v1;v2-=a.v2;v3-=a.v3;;return *this;}
      method V (line 23) | V& operator*=(V a){v1*=a.v1;v2*=a.v2;v3*=a.v3;;return *this;}
      method V (line 24) | V& operator/=(V a){v1/=a.v1;v2/=a.v2;v3/=a.v3;;return *this;}
      method V (line 26) | V operator+(V a) const{return V(*this)+=a;}
      method V (line 27) | V operator-(V a) const{return V(*this)-=a;}
      method V (line 28) | V operator*(V a) const{return V(*this)*=a;}
      method V (line 29) | V operator/(V a) const{return V(*this)/=a;}
      method norm (line 31) | tuple<M1, M2, M3> norm() const{return make_tuple(v1,v2,v3);}
  function drop (line 80) | void drop(const T &x){cout<<x<<endl;exit(0);}
  function CODEFLYER2018_F (line 83) | signed CODEFLYER2018_F(){
  type Point (line 343) | struct Point{
    method Point (line 345) | Point():x(0),y(0){}
    method Point (line 346) | Point(V x,V y):x(x),y(y){}
  function Point (line 351) | Point getP(){
    method Point (line 345) | Point():x(0),y(0){}
    method Point (line 346) | Point(V x,V y):x(x),y(y){}
  function JAG2018SUMMER_DAY2_F (line 357) | signed JAG2018SUMMER_DAY2_F(){
  function main (line 419) | signed main(){

FILE: polynomial/interpolate.cpp
  type Interpolate (line 19) | struct Interpolate : MultiEval<T>{
    method Poly (line 24) | Poly interpolate(const vector<T> &xs,const vector<T> &ws,int l,int r){
    method build (line 31) | vector<T> build(const vector<T> &xs,const vector<T> &ys){
  function main (line 45) | signed main(){

FILE: polynomial/lagrangeinterpolation.cpp
  function M (line 7) | M lagrange_interpolation(vector<M> &y,M t){
  function main (line 30) | signed main(){

FILE: polynomial/multieval.cpp
  type MultiEval (line 17) | struct MultiEval{
    method MultiEval (line 22) | MultiEval(Conv conv):FPS(conv){}
    method dfs (line 26) | void dfs(const vector<T> &cs,int l,int r){
    method multi_eval (line 37) | void multi_eval(Poly ps,vector<T> &ws,int l,int r){
    method build (line 47) | vector<T> build(Poly ps,const vector<T> &cs){
  function main (line 58) | signed main(){

FILE: polynomial/polynomial.cpp
  type Polynomial (line 7) | struct Polynomial{
    method Polynomial (line 10) | Polynomial():co(1,T(1)){}
    method Polynomial (line 11) | Polynomial(int sz):co(sz,0){}
    method Polynomial (line 12) | Polynomial(vector<T> co):co(co){}
    method size (line 14) | size_t size() const{
    method shrink (line 18) | void shrink(){
    method reduce (line 23) | void reduce(){
    method print (line 32) | void print(){
    method T (line 53) | T operator[](int i) const{
    method T (line 57) | T &operator[](int i){
    method P (line 61) | P operator-() const{
    method P (line 67) | P operator+(const P &a) const{
    method P (line 75) | P operator-(const P &a) const{return *this+(-a);}
    method P (line 77) | P operator*(const P &a) const{
    method P (line 87) | P pow(const P &a,int k) const{
    method divide (line 93) | pair<P, P> divide(const P &a) const{
    method P (line 108) | P operator/(const P &a) const{return divide(a).first;}
    method P (line 109) | P operator%(const P &a) const{return divide(a).second;}
  function gcd (line 113) | Polynomial<T> gcd(Polynomial<T> a,Polynomial<T> b){
  function main (line 123) | signed main(){

FILE: polynomial/recursivesequence.cpp
  type RecursiveSequence (line 9) | struct RecursiveSequence{
    method RecursiveSequence (line 11) | RecursiveSequence(int n):add(n),sub(n+1){}
    method query (line 14) | void query(int l,int r){
    method build (line 20) | vector<T> build(vector<T> as,vector<T> cs){
  function main (line 50) | signed main(){

FILE: segtree/2d/ushi.cpp
  type SegmentTree2D (line 7) | struct SegmentTree2D{
    method SegmentTree2D (line 12) | SegmentTree2D(F f_,T ti_):f(f_),ti(ti_){}
    method preupdate (line 15) | void preupdate(index_t p,index_t q){
    method compress (line 19) | void compress(vector<index_t> &vs){
    method idx (line 24) | int idx(index_t v,const vector<index_t> &vs){
    method build (line 33) | void build(){
    method update (line 70) | void update(int p,int q,T v,int k,int l,int r){
    method update (line 87) | void update(index_t p,index_t q,T v){
    method T (line 91) | T query(int pa,int pb,int qa,int qb,int k,int l,int r){
    method T (line 100) | T query(index_t pa,index_t pb,index_t qa,index_t qb){
  function ABC266_H (line 113) | signed ABC266_H(){
  function main (line 154) | signed main(){

FILE: segtree/basic/dual.cpp
  type SegmentTree (line 7) | struct SegmentTree{
    method SegmentTree (line 14) | SegmentTree(H h,E ei):h(h),ei(ei){}
    method init (line 16) | void init(int n_){
    method propagate (line 22) | inline void propagate(int k){
    method thrust (line 29) | inline void thrust(int k){
    method update (line 33) | void update(int a,int b,E x){
    method E (line 43) | E get_val(int a){
    method set_val (line 48) | void set_val(int a,E x){
  function main (line 56) | signed main(){

FILE: segtree/basic/lazy.cpp
  type SegmentTree (line 7) | struct SegmentTree{
    method SegmentTree (line 19) | SegmentTree(F f,G g,H h,T ti,E ei):
    method init (line 22) | void init(int n_){
    method build (line 29) | void build(const vector<T> &v){
    method T (line 37) | inline T reflect(int k){
    method propagate (line 41) | inline void propagate(int k){
    method thrust (line 49) | inline void thrust(int k){
    method recalc (line 53) | inline void recalc(int k){
    method update (line 58) | void update(int a,int b,E x){
    method set_val (line 70) | void set_val(int a,T x){
    method T (line 76) | T query(int a,int b){
    method find (line 89) | int find(int st,C &check,T &acc,int k,int l,int r){
    method find (line 107) | int find(int st,C &check){
  function CFR569_C (line 115) | signed CFR569_C(){
  function main (line 164) | signed main(){

FILE: segtree/basic/ushi.cpp
  type SegmentTree (line 7) | struct SegmentTree{
    method SegmentTree (line 14) | SegmentTree(F f,T ti):f(f),ti(ti){}
    method init (line 16) | void init(int n_){
    method build (line 22) | void build(const vector<T> &v){
    method set_val (line 30) | void set_val(int k,T x){
    method T (line 36) | T query(int a,int b){
    method max_right (line 47) | int max_right(int s,C &check,T &acc,int k,int l,int r){
    method max_right (line 66) | int max_right(int s,C &check){
  function main (line 74) | signed main(){

FILE: segtree/count/dynamic_offline.cpp
  type RangeCount (line 7) | struct RangeCount{
    type BIT (line 8) | struct BIT{
      method BIT (line 10) | BIT(int n){dat.assign(++n,0);}
      method T (line 11) | T sum(int k){
      method add (line 16) | void add(int k,T v){
    method RangeCount (line 23) | RangeCount(int n):n(n){
    method preupdate (line 27) | void preupdate(int a,Key x){
    method build (line 34) | void build(){
    method update (line 42) | void update(int a,Key x,T z){
    method T (line 51) | T calc(int k,Key x,Key y){
    method T (line 58) | T query(int a,int b,Key x,Key y){
  function main (line 71) | signed main(){

FILE: segtree/count/static.cpp
  type SegmentTree (line 7) | struct SegmentTree{
    method SegmentTree (line 11) | SegmentTree(int n,vector<P> vs):n(n){
    method query (line 27) | inline int query(int a,int b,Key c,Key d){
  function main (line 43) | signed main(){

FILE: segtree/persistent/ushi.cpp
  type SegmentTree (line 7) | struct SegmentTree{
    method SegmentTree (line 11) | SegmentTree(F f,T ti):f(f),ti(ti){}
    type Node (line 13) | struct Node{
      method Node (line 16) | Node(T dat):dat(dat){l=r=nullptr;}
    method Node (line 19) | Node* clone(Node *a){
      method Node (line 16) | Node(T dat):dat(dat){l=r=nullptr;}
    method Node (line 23) | Node* reflect(Node *a){
      method Node (line 16) | Node(T dat):dat(dat){l=r=nullptr;}
    method Node (line 29) | Node* build(const vector<T> &v){
      method Node (line 16) | Node(T dat):dat(dat){l=r=nullptr;}
    method Node (line 45) | Node* set_val(Node* t,int k,T x,int h){
      method Node (line 16) | Node(T dat):dat(dat){l=r=nullptr;}
    method T (line 56) | T query(Node* t,int l,int r,int lb,int ub){
    method Node (line 63) | Node* set_val(Node* t,int k,T x){
      method Node (line 16) | Node(T dat):dat(dat){l=r=nullptr;}
    method T (line 67) | T query(Node* t,int l,int r){
  function main (line 74) | signed main(){

FILE: segtree/types/offline.cpp
  type RangeCount (line 7) | struct RangeCount{
    type BIT (line 8) | struct BIT{
      method BIT (line 10) | BIT(int n){dat.assign(++n,0);}
      method T (line 11) | T sum(int k){
      method add (line 16) | void add(int k,T v){
    method RangeCount (line 23) | RangeCount(int n_){
    method preupdate (line 29) | void preupdate(int a,int x){
    method build (line 36) | void build(){
    method update (line 44) | void update(int a,int x,int z){
    method T (line 53) | T calc(int k,int x,int y){
    method T (line 60) | T query(int a,int b,int x,int y){
  type RangeTypes (line 70) | struct RangeTypes{
    type range (line 71) | struct range{
      method range (line 73) | range(int l,int r,int c):l(l),r(r),c(c){}
    method RangeTypes (line 89) | RangeTypes(int n_,int m):m(m),time(0),se(m+1),rc(n_){
    method get (line 105) | int get(int k) const{
    method reset (line 113) | void reset(int a,int v){
    method update (line 121) | void update(const int a,const int b,const int c){
    method count (line 204) | void count(const int a,const int b){
    method build (line 208) | vector<int> build(){
  function chmin (line 226) | inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
  function chmax (line 227) | inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
  type EulerTour (line 230) | struct EulerTour{
    method EulerTour (line 235) | EulerTour(int n):n(n),G(n),ls(n),rs(n){}
    method add_edge (line 237) | void add_edge(int u,int v){
    method dfs (line 242) | void dfs(int v,int p){
    method build (line 249) | void build(int r=0){
  function main (line 257) | signed main(){

FILE: segtree/types/online.cpp
  type RangeTypes (line 11) | struct RangeTypes{
    type range (line 15) | struct range{
      method range (line 17) | range(int l,int r,int c):l(l),r(r),c(c){}
    method RangeTypes (line 31) | RangeTypes(int n_,int m):m(m),time(0),se(m+1){
    method get (line 53) | int get(int k) const{
    method reset (line 61) | void reset(int a,int v){
    method update (line 72) | void update(const int a,const int b,const int c){
    method query (line 155) | int query(const int a,const int b,const int c,const int d) const{
    method count (line 169) | int count(const int a,const int b) const{
  function chmin (line 175) | inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
  function chmax (line 176) | inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
  type EulerTour (line 179) | struct EulerTour{
    method EulerTour (line 184) | EulerTour(int n):n(n),G(n),ls(n),rs(n){}
    method add_edge (line 186) | void add_edge(int u,int v){
    method dfs (line 191) | void dfs(int v,int p){
    method build (line 198) | void build(int r=0){
  function main (line 206) | signed main(){

FILE: string/ahocorasick.cpp
  type AhoCorasick (line 12) | struct AhoCorasick : Trie<X+1>{
    method build (line 20) | void build(){
    method count (line 68) | int count(int pos){
    method match (line 73) | long long match(string s){
    method frequency (line 84) | vector<int> frequency(string s){
  function main (line 98) | signed main(){

FILE: string/editdistance.cpp
  function edit_distance (line 11) | int edit_distance(string s,string t){
  function main (line 28) | signed main(){

FILE: string/knuthmorrispratt.cpp
  function knuth_morris_pratt (line 7) | vector<int> knuth_morris_pratt(const string &s){
  function pattern_match (line 18) | vector<int> pattern_match(string s,string t){
  function chmin (line 37) | inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
  function chmax (line 38) | inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
  function ABC135_F (line 43) | signed ABC135_F(){
  function main (line 96) | signed main(){

FILE: string/longestcommonprefix.cpp
  type LongestCommonPrefix (line 13) | struct LongestCommonPrefix{
    method LongestCommonPrefix (line 18) | LongestCommonPrefix(const Seq &s):sa(s){
    method query (line 46) | int query(int a,int b){
    method lcp (line 54) | int lcp(int a,int b){
  function main (line 61) | signed main(){

FILE: string/longestcommonsubstring.cpp
  function string (line 7) | string longest_common_substring(string s,string t){
  function DP_F (line 37) | signed DP_F(){
  function main (line 48) | signed main(){

FILE: string/manacher.cpp
  function manacher (line 7) | vector<int> manacher(string s){
  function main (line 22) | signed main(){

FILE: string/morrispratt.cpp
  function morris_pratt (line 9) | vector<int> morris_pratt(const string &s){
  function minimum_period (line 19) | vector<int> minimum_period(const string &s){
  function ARC060_F (line 28) | signed ARC060_F(){
  function main (line 65) | signed main(){

FILE: string/palindromictree.cpp
  type PalindromicTree (line 6) | struct PalindromicTree{
    type node (line 7) | struct node{
      method node (line 10) | node():len(-1){}
      method node (line 11) | node(int len,int suf,int app,int cnt)
    method PalindromicTree (line 18) | PalindromicTree(const string &s)
    method add_char (line 29) | bool add_char(const string &s,int pos){
    method calc_order (line 64) | void calc_order(){
    method calc_count (line 72) | void calc_count(){
    method size (line 77) | size_t size()const{return n;}
  function main (line 82) | signed main(){

FILE: string/parse.cpp
  function expression (line 13) | int expression(string& s,int& p){
  function term (line 31) | int term(string& s,int& p){
  function factor (line 54) | int factor(string& s,int& p){
  function number (line 66) | int number(string& s,int& p){
  function main (line 74) | signed main(){

FILE: string/rectanglehash.cpp
  function rectangle_hash (line 12) | auto rectangle_hash(vector<string> vs,int r,int c){
  function main (line 32) | signed main(){

FILE: string/rollinghash.cpp
  type RollingHash (line 7) | struct RollingHash{
    method RollingHash (line 10) | RollingHash(vector<T> vs){init(vs);}
    method RollingHash (line 11) | RollingHash(string &s){
    method init (line 16) | void init(vector<T> vs){
    method T (line 26) | T find(int l,int r){
  function main (line 34) | signed main(){

FILE: string/run.cpp
  type Run (line 11) | namespace Run{
    function sub (line 17) | vector<T> sub(const vector<C> &xs,const vector<C> &ys){
    function dfs (line 37) | void dfs(int l,int r,const vector<C> &cs){
    function enumerate (line 66) | vector<vector<P>> enumerate(const vector<C> &cs){
    function enumerate (line 89) | vector<vector<P>> enumerate(string ss){
  function main (line 95) | signed main(){

FILE: string/split.cpp
  function split (line 6) | vector<string> split(string& s,char c){
  function main (line 18) | signed main(){

FILE: string/suffixarray.cpp
  type SuffixArray (line 7) | struct SuffixArray{
    method SuffixArray (line 11) | SuffixArray(const Seq &s_):s(s_){
    method lt_substr (line 61) | bool lt_substr(const Seq &t,int si,int ti){
    method lower_bound (line 71) | int lower_bound(Seq t){
    method upper_bound (line 81) | int upper_bound(Seq t){
    method count (line 89) | int count(Seq t){
  function main (line 96) | signed main(){

FILE: string/trie.cpp
  type Trie (line 7) | struct Trie{
    type Node (line 8) | struct Node{
      method Node (line 12) | Node():idx(-1){fill(nxt.begin(),nxt.end(),-1);}
    method Trie (line 19) | Trie(F conv):conv(conv){vs.emplace_back();}
    method Trie (line 20) | Trie(char start):Trie([=](char a){return a-start;}){}
    method add (line 26) | void add(const string &s,int x){
    method find (line 43) | int find(const string &s){
    method move (line 53) | int move(int pos,char c){
    method size (line 58) | int size(){return vs.size();}
    method idx (line 60) | int idx(int pos){
    method idxs (line 64) | vector<int> idxs(int pos){
  function main (line 71) | signed main(){

FILE: string/zalgorithm.cpp
  function zalgorithm (line 9) | vector<int> zalgorithm(vector<T> vs){
  function zalgorithm (line 28) | vector<int> zalgorithm(string s){
  function main (line 33) | signed main(){

FILE: test/aoj/0109.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0168.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0233.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0294.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0314.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/0343.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0367.linkcuttree.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0367.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/0367.toptree.test.cpp
  function ll (line 13) | ll calc(ll val){return val%K?val:0;}
  type Vertex (line 15) | struct Vertex{
    method Vertex (line 18) | Vertex(ll w=0):w(w),handle(nullptr){}
  type Cluster (line 21) | struct Cluster{
    method Cluster (line 23) | Cluster(ll edge=-1):edge(edge),all(0),lft(0),rgh(0){}
    method toggle (line 24) | void toggle(){
    method Cluster (line 27) | static Cluster compress(Cluster x,Vertex *v,Cluster y){
    method Cluster (line 41) | static Cluster rake(Cluster x,Cluster){
  function main (line 46) | signed main(){

FILE: test/aoj/0377.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0391.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0402.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0403.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/0415.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/0422.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0423.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/0424.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0425.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0437.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/0438.test.cpp
  type T (line 13) | struct T
    method T (line 19) | T():nxt(nullptr){}
    method T (line 20) | T(Node* nxt,char c):nxt(nxt),c(c){}
  type T (line 16) | struct T{
    method T (line 19) | T():nxt(nullptr){}
    method T (line 20) | T(Node* nxt,char c):nxt(nxt),c(c){}
  function main (line 23) | signed main(){

FILE: test/aoj/0439.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/0502.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0558.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0563.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/0596.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/0613.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/1069.test.cpp
  function ll (line 16) | ll sqrt(ll x){
  function main (line 28) | signed main(){

FILE: test/aoj/1197.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/1254.test.cpp
  type Point (line 12) | struct Point{
    method Point (line 14) | Point(){}
    method Point (line 15) | Point(double x,double y) :x(x),y(y){}
    method Point (line 16) | Point operator+(Point p) {return Point(x+p.x,y+p.y);}
    method Point (line 17) | Point operator-(Point p) {return Point(x-p.x,y-p.y);}
    method Point (line 18) | Point operator*(double k){return Point(x*k,y*k);}
    method Point (line 19) | Point operator/(double k){return Point(x/k,y/k);}
  function norm (line 25) | double norm(Vector a){
  function abs (line 28) | double abs(Vector a){
  function cross (line 31) | double cross(Vector a,Vector b){
  function calc (line 35) | bool calc(Point a1,Point a2,Point b1,Point b2){
  function main (line 48) | signed main(){

FILE: test/aoj/1293.test.cpp
  function P (line 17) | P expr(string s,int &p){
  function P (line 40) | P factor(string s,int &p){
  function P (line 51) | P term(string s,int &p){
  function number (line 83) | int number(string s,int &p){
  function P (line 90) | P calc(string s){
  function main (line 95) | signed main(){

FILE: test/aoj/1300.test.cpp
  function S (line 13) | S add(S x,S y){
  function S (line 18) | S mul(S x,int k){
  function S (line 24) | S term(string s){
  function conv (line 56) | vector<S> conv(string s){
  function solve (line 63) | signed solve(string s){
  function main (line 154) | signed main(){

FILE: test/aoj/1308.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/1312.test.cpp
  function conv (line 11) | int conv(char c){
  function decode (line 20) | vector<string> decode(vector<string> vs,int h,int w){
  function main (line 29) | signed main(){

FILE: test/aoj/1328.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/1338.test.cpp
  function print (line 14) | void print(frac f){
  function frac (line 21) | frac norm2(frac a){
  function main (line 29) | signed main(){

FILE: test/aoj/1508.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/1549.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/1579.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/1595.linkcuttree.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/1595.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/1595.toptree.test.cpp
  type Vertex (line 10) | struct Vertex{
    method Vertex (line 13) | Vertex(int idx=-1):handle(nullptr),idx(idx){}
  type Cluster (line 16) | struct Cluster{
    method Cluster (line 18) | Cluster(int l=0):ans(l),lf(l),rg(l),len(l){}
    method Cluster (line 19) | Cluster(int ans,int lf,int rg,int len):
    method toggle (line 21) | void toggle(){swap(lf,rg);}
    method Cluster (line 22) | static Cluster compress(Cluster x,Vertex*,Cluster y){
    method Cluster (line 29) | static Cluster rake(Cluster x,Cluster y){
  function main (line 34) | signed main(){

FILE: test/aoj/1599.test.cpp
  function main (line 11) | int main(){

FILE: test/aoj/1607.test.cpp
  function main (line 24) | signed main(){

FILE: test/aoj/1613.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/1615.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/1630.test.cpp
  function V (line 25) | V expr(string &s,int &p,int d){
  function V (line 43) | V term(string &s,int &p,int d){
  function V (line 60) | V factor(string &s,int &p,int d){
  function V (line 71) | V number(string &s,int &p){
  function main (line 76) | signed main(){

FILE: test/aoj/1642.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2060.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2187.test.cpp
  function solve (line 12) | signed solve(){
  function main (line 40) | signed main(){

FILE: test/aoj/2212.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2222.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2230.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2235.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2257.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/2270.test.cpp
  function main (line 15) | signed main(){

FILE: test/aoj/2286.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2290.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/2292.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2294.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2308.test.cpp
  type Point (line 14) | struct Point{
    method Point (line 16) | Point(){}
    method Point (line 17) | Point(D x,D y):x(x),y(y){}
  function istream (line 20) | istream &operator>>(istream &is,Point &p){
  function main (line 25) | signed main(){

FILE: test/aoj/2309.tarjan.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/2309.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/2313.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2324.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2328.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2359.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/2370.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2397.test.cpp
  function main (line 15) | signed main(){

FILE: test/aoj/2405.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2415.knuthyao.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2415.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2432.ignore.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2444.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2446.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2450.linkcuttree.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2450.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2488.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2513.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2560.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2563.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/2603.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2624.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2627.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/2636.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2644.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2646.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/2647.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2659.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/2667.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2674.count.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/2674.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2679.test.cpp
  type ARR (line 11) | struct ARR{
    method ARR (line 13) | ARR(){fill(val.begin(),val.end(),0);}
    method ARR (line 14) | ARR(int x){fill(val.begin(),val.end(),x);}
    method ARR (line 17) | ARR operator+(const ARR &oth) const{
    method ARR (line 23) | ARR operator-(const ARR &oth) const{
    method ARR (line 29) | ARR operator-() const{
    method ARR (line 35) | ARR operator*(const int &k) const{
    method ARR (line 41) | ARR operator/(const int &k) const{
  type std (line 58) | namespace std {
    class numeric_limits<ARR> (line 59) | class numeric_limits<ARR> {
      method ARR (line 61) | static ARR max() {return ARR(numeric_limits<int>::max());}
  function main (line 65) | int main(){

FILE: test/aoj/2687.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2711.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2720.test.cpp
  function T (line 12) | T mpow(T x,T n,T m){
  function main (line 23) | signed main(){

FILE: test/aoj/2725.linecontainer.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2725.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2736.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2790.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/2842.BIT2D.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2842.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/2871.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2872.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2890.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2891.test.cpp
  function main (line 9) | signed main(){

FILE: test/aoj/2934.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2948.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/2951.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/2959.test.cpp
  function dfs (line 15) | void dfs(vector<int> &as,vector<int> &bs,int l,int r){
  function main (line 29) | signed main(){

FILE: test/aoj/2968.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2969.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/2970.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2971.test.cpp
  function check (line 30) | void check(T x,T y){if(x!=y) drop("No");}
  function dfs (line 32) | void dfs(int v){
  function main (line 58) | signed main(){

FILE: test/aoj/2975.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2977.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/2979.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2981.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/2983.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/2985.garner.test.cpp
  function main (line 19) | signed main(){

FILE: test/aoj/2985.test.cpp
  function main (line 19) | signed main(){

FILE: test/aoj/2995.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/3024.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/3033.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/3035.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/3037.test.cpp
  type Vertex (line 12) | struct Vertex{
    method Vertex (line 15) | Vertex(ll val=0):handle(nullptr),val(val){}
  type Cluster (line 18) | struct Cluster{
    method Cluster (line 20) | Cluster():sm(0),md(0),chd(0),ma(0){}
    method toggle (line 21) | void toggle(){}
    method Cluster (line 22) | static Cluster compress(Cluster x,Vertex *v,Cluster y){
    method Cluster (line 29) | static Cluster rake(Cluster x,Cluster y){
  function main (line 36) | signed main(){

FILE: test/aoj/3047.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/3053.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/3058.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/3062.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/3063.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/3069.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/3072.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/3073.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/3074.test.cpp
  type Ring (line 18) | struct Ring{
    method Ring (line 20) | Ring(){}
    method Ring (line 21) | Ring(vector<M> dat):dat(dat){}
    method Ring (line 24) | Ring operator*(const Ring &a)const{
    method Ring (line 29) | Ring operator+(const Ring &a)const{
  function Ring (line 37) | Ring Ring::add_identity(){return add_id;}
    method Ring (line 20) | Ring(){}
    method Ring (line 21) | Ring(vector<M> dat):dat(dat){}
    method Ring (line 24) | Ring operator*(const Ring &a)const{
    method Ring (line 29) | Ring operator+(const Ring &a)const{
  function Ring (line 38) | Ring Ring::mul_identity(){return mul_id;}
    method Ring (line 20) | Ring(){}
    method Ring (line 21) | Ring(vector<M> dat):dat(dat){}
    method Ring (line 24) | Ring operator*(const Ring &a)const{
    method Ring (line 29) | Ring operator+(const Ring &a)const{
  function main (line 40) | signed main(){

FILE: test/aoj/3081.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/3084.test.cpp
  function main (line 21) | signed main(){

FILE: test/aoj/3086.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/3102.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/3112.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/3117.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/3120.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/3138.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/3142.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/3143.test.cpp
  function main (line 15) | signed main(){

FILE: test/aoj/3148.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/3168.test.cpp
  function main (line 15) | signed main(){

FILE: test/aoj/3179.test.cpp
  type Vertex (line 12) | struct Vertex{
    method Vertex (line 15) | Vertex():v(0),handle(nullptr){}
    method Vertex (line 16) | Vertex(M v):v(v),handle(nullptr){}
  type Cluster (line 19) | struct Cluster{
    method Cluster (line 24) | Cluster(M len=M(0)):len(len),sum_v(0),sum_l(0),sum_r(0),rake_v(0),rake...
    method toggle (line 25) | void toggle(){
    method Cluster (line 28) | static Cluster compress(Cluster x,Vertex *v,Cluster y){
    method Cluster (line 35) | static Cluster rake(Cluster x,Cluster y){
  function main (line 42) | signed main(){

FILE: test/aoj/3183.test.cpp
  function main (line 20) | signed main(){

FILE: test/aoj/3198.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/3208.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/3213.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/3506.test.cpp
  function main (line 17) | signed main(){

FILE: test/aoj/3518.test.cpp
  function main (line 16) | signed main(){

FILE: test/aoj/ALDS1_10_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ALDS1_14_B.knuthmorrispratt.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ALDS1_14_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ALDS1_14_C.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/ALDS1_15_B.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/ALDS1_1_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ALDS1_5_D.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/ALDS1_9_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DPL_1_E.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_3_B.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_3_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DPL_5_A.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_5_B.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_5_C.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DPL_5_D.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_5_E.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DPL_5_F.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_5_G.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DPL_5_H.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_5_I.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DPL_5_J.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DPL_5_K.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DPL_5_L.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DSL_1_A.quickfind.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_1_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_1_B.test.cpp
  function main (line 10) | int main(){

FILE: test/aoj/DSL_2_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_2_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_2_D.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_2_E.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_2_F.bbst.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DSL_2_F.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_2_G.bbst.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DSL_2_H.bbst.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DSL_2_H.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_2_I.bbst.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/DSL_2_I.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_3_D.cartesiantree.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/DSL_3_D.disjointsparsetable.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_3_D.slidingwindowaggregation.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_3_D.sparsetable.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/DSL_3_D.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_1_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_1_B.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/GRL_2_A.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/GRL_2_B.tarjan.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_2_B.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/GRL_3_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_3_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_4_B.ignore.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_5_A.linkcuttree.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/GRL_5_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_5_C.lca.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_5_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/GRL_5_D.linkcuttree.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/GRL_5_D.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/GRL_5_E.linkcuttree.test.cpp
  function main (line 11) | signed main(){

FILE: test/aoj/GRL_6_A.test.cpp
  function main (line 10) | int main(){

FILE: test/aoj/GRL_6_B.test.cpp
  function main (line 10) | int main(){

FILE: test/aoj/GRL_7_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ITP1_11_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ITP1_11_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ITP1_11_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/ITP1_11_D.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_1_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_1_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_1_D.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_1_E.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_2_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_2_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_2_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_2_D.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_2_E.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/NTL_2_F.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/2334.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/2448.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/geometry/2454.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/geometry/3049.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/geometry/3056.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_1_A.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_1_B.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/geometry/CGL_1_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_2_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_2_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_2_C.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_2_D.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_3_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_3_B.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_3_C.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_4_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_4_B.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_4_C.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/geometry/CGL_5_A.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_6_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_7_A.test.cpp
  function main (line 10) | signed main(){

FILE: test/aoj/geometry/CGL_7_D.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_7_E.test.cpp
  function main (line 12) | signed main(){

FILE: test/aoj/geometry/CGL_7_F.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_7_G.test.cpp
  function main (line 13) | signed main(){

FILE: test/aoj/geometry/CGL_7_H.test.cpp
  function main (line 14) | signed main(){

FILE: test/aoj/geometry/CGL_7_I.test.cpp
  function main (line 13) | signed main(){

FILE: test/yosupo/assignment.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/associative_array.test.cpp
  function main (line 15) | signed main(){

FILE: test/yosupo/bernoulli_number.test.cpp
  function main (line 15) | signed main(){

FILE: test/yosupo/bipartitematching.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/bitwise_and_convolution.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/bitwise_xor_convolution.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/cartesian_tree.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/convolution_mod.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/convolution_mod_1000000007.garner.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/convolution_mod_1000000007.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/cycle_detection.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/discrete_logarithm_mod.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/dominatortree.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/dynamic_sequence_range_affine_range_sum.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/dynamic_tree_vertex_add_path_sum.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/dynamic_tree_vertex_add_subtree_sum.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/dynamic_tree_vertex_add_subtree_sum.toptree.test.cpp
  type Vertex (line 11) | struct Vertex{
    method Vertex (line 14) | Vertex(ll val=0):handle(nullptr),val(val){}
  type Cluster (line 17) | struct Cluster{
    method Cluster (line 19) | Cluster(ll res=0):res(res){}
    method toggle (line 20) | void toggle(){}
    method Cluster (line 21) | static Cluster compress(Cluster x,Vertex* v,Cluster y){
    method Cluster (line 24) | static Cluster rake(Cluster x,Cluster y){
  function main (line 29) | signed main(){

FILE: test/yosupo/dynamic_tree_vertex_set_path_composite.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/dynamic_tree_vertex_set_path_composite.toptree.test.cpp
  type Vertex (line 17) | struct Vertex{
    method Vertex (line 20) | Vertex(L val=L()):handle(nullptr),val(val){}
  type Cluster (line 23) | struct Cluster{
    method Cluster (line 25) | Cluster():res(L(1,0)){}
    method Cluster (line 26) | Cluster(L val):res(val){}
    method Cluster (line 27) | Cluster(P res):res(res){}
    method toggle (line 28) | void toggle(){swap(res.x,res.y);}
    method Cluster (line 29) | static Cluster compress(Cluster x,Vertex* v,Cluster y){
    method Cluster (line 32) | static Cluster rake(Cluster x,Cluster){
  function main (line 37) | signed main(){

FILE: test/yosupo/enumerate_primes.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/enumerate_triangles.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/exp_of_formal_power_series.test.cpp
  function main (line 18) | signed main(){

FILE: test/yosupo/find_linear_recurrence.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/frequency_table_of_tree_distance.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/inv_of_formal_power_series.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/kth_root_integer.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/kth_term_of_linearly_recurrent_sequence.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/lca.linkcuttree.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/lca.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/line_add_get_min.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/log_of_formal_power_series.test.cpp
  function main (line 17) | signed main(){

FILE: test/yosupo/manhattanmst.test.cpp
  function main (line 16) | signed main(){

FILE: test/yosupo/many_aplusb.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/matrix_det.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/maximum_independent_set.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/min_cost_b_flow.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/montmort_number_mod.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/multipoint_evaluation.test.cpp
  function main (line 17) | signed main(){

FILE: test/yosupo/number_of_substrings.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/partition_function.test.cpp
  function main (line 15) | signed main(){

FILE: test/yosupo/persistent_queue.test.cpp
  function main (line 16) | signed main(){

FILE: test/yosupo/point_add_range_sum.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/point_add_rectangle_sum.test.cpp
  function main (line 15) | signed main(){

FILE: test/yosupo/point_set_range_composite.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/polynomial_interpolation.test.cpp
  function main (line 19) | signed main(){

FILE: test/yosupo/polynomial_taylor_shift.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/pow_of_formal_power_series.test.cpp
  function main (line 19) | signed main(){

FILE: test/yosupo/queue_operate_all_composite.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/range_affine_range_sum.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/range_kth_smallest.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/rectangle_sum.test.cpp
  function main (line 15) | signed main(){

FILE: test/yosupo/runenumerate.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/scc.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/segment_add_get_min.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/set_xor_min.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/sharp_p_subset_sum.test.cpp
  function main (line 18) | signed main(){

FILE: test/yosupo/shortest_path.test.cpp
  function main (line 15) | signed main(){

FILE: test/yosupo/sort_points_by_argument.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/sqrt_mod.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/sqrt_of_formal_power_series.test.cpp
  function main (line 17) | signed main(){

FILE: test/yosupo/static_range_frequency.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/static_range_inversions_query.test.cpp
  function main (line 13) | signed main(){

FILE: test/yosupo/static_range_sum.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/staticrmq.disjointsparsetable.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/staticrmq.sparsetable.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/stirling_number_of_the_first_kind.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/stirling_number_of_the_second_kind.test.cpp
  function main (line 14) | signed main(){

FILE: test/yosupo/subset_convolution.test.cpp
  function main (line 12) | signed main(){

FILE: test/yosupo/suffixarray.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/sum_of_floor_of_linear.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/tetration_mod.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/tree_decomposition_width_2.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/tree_diameter.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/two_edge_connected_components.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/two_sat.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/unionfind.test.cpp
  function main (line 10) | signed main(){

FILE: test/yosupo/vertex_add_path_sum.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/vertex_add_subtree_sum.test.cpp
  function main (line 11) | signed main(){

FILE: test/yosupo/zalgorithm.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/0022.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/0104.test.cpp
  function main (line 13) | signed main(){

FILE: test/yukicoder/0143.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/0206.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/0222.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/0399.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/0444.test.cpp
  function main (line 14) | signed main(){

FILE: test/yukicoder/0472.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/0771.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/0831.test.cpp
  function main (line 15) | signed main(){

FILE: test/yukicoder/1013.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/1504.test.cpp
  function main (line 14) | signed main(){

FILE: test/yukicoder/1580.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/1665.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/1732.test.cpp
  function main (line 13) | signed main(){

FILE: test/yukicoder/1923.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/1937.test.cpp
  function main (line 14) | signed main(){

FILE: test/yukicoder/1948.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/1950.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/1973.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/2063.test.cpp
  function main (line 14) | signed main(){

FILE: test/yukicoder/2085.test.cpp
  function main (line 14) | signed main(){

FILE: test/yukicoder/2113.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/2125.test.cpp
  function dfs (line 14) | pair<bigint, bigint> dfs(int l,int r){
  function main (line 25) | signed main(){

FILE: test/yukicoder/2147.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/2520.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/2587.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/2600.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/2744.test.cpp
  function main (line 15) | signed main(){

FILE: test/yukicoder/2772.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/3211.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/3227.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/3267.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/3277.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/3354.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/3405.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/3407.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/3453.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/3592.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/3912.test.cpp
  function main (line 13) | signed main(){

FILE: test/yukicoder/3961.test.cpp
  function main (line 16) | signed main(){

FILE: test/yukicoder/4072.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/4117.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/4271.avx2.test.cpp
  function uint (line 14) | inline uint add_mod(uint a, uint b) {
  function uint (line 18) | uint mul(uint x,uint y){
  function main (line 26) | signed main(){

FILE: test/yukicoder/4271.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/4387.test.cpp
  function main (line 16) | signed main(){

FILE: test/yukicoder/4474.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/4569.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/4706.test.cpp
  type Vertex (line 11) | struct Vertex{
    method Vertex (line 13) | Vertex():handle(nullptr){}
  type Cluster (line 18) | struct Cluster{
    method Cluster (line 21) | Cluster(ll len=INF):len(len),lft(len),rgh(len),mid(INF),ans(INF){}
    method toggle (line 22) | void toggle(){
    method Cluster (line 25) | static Cluster compress(Cluster x,Vertex *,Cluster y){
    method Cluster (line 32) | static Cluster rake(Cluster x,Cluster y){
  function main (line 39) | signed main(){

FILE: test/yukicoder/4778.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/4852.test.cpp
  function main (line 19) | signed main(){

FILE: test/yukicoder/4862.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/4872.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/4918.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/4941.test.cpp
  function main (line 10) | signed main(){

FILE: test/yukicoder/5011.test.cpp
  function main (line 11) | signed main(){

FILE: test/yukicoder/5025.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/5061.test.cpp
  function main (line 17) | signed main(){

FILE: test/yukicoder/5223.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/5633.test.cpp
  function main (line 22) | signed main(){

FILE: test/yukicoder/6680.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/7107.test.cpp
  function main (line 12) | signed main(){

FILE: test/yukicoder/9158.test.cpp
  function main (line 12) | signed main(){

FILE: tools/all_permutations.cpp
  function all_permutations (line 7) | void all_permutations(int n,F f){
  function main (line 14) | signed main(){

FILE: tools/avx2.cpp
  function main (line 12) | signed main(){

FILE: tools/bigint.cpp
  type bigint (line 11) | struct bigint {
    method bigint (line 21) | bigint():sign(1){}
    method bigint (line 23) | bigint(ll v){*this=v;}
    method bigint (line 25) | bigint(const string &s){read(s);}
    method bigint (line 27) | static bigint add_identity(){return bigint(0);}
    method bigint (line 28) | static bigint mul_identity(){return bigint(1);}
    method bigint (line 36) | bigint operator+(const bigint &v) const{
    method bigint (line 50) | bigint operator-(const bigint &v) const{
    method bigint (line 79) | bigint operator*(ll v) const{
    method divmod (line 85) | pair<bigint,bigint> divmod(const bigint &a1,const bigint &b1){
    method bigint (line 110) | bigint operator/(const bigint &v) const{
    method bigint (line 114) | bigint operator%(const bigint &v) const{
    method bigint (line 128) | bigint operator/(ll v) const{
    method ll (line 134) | ll operator%(ll v) const{
    method trim (line 185) | void trim(){
    method isZero (line 190) | bool isZero() const{
    method bigint (line 194) | bigint operator-() const{
    method bigint (line 200) | bigint abs() const{
    method ll (line 206) | ll longValue() const{
    method bigint (line 212) | bigint gcd(const bigint &a,const bigint &b){
    method bigint (line 216) | bigint lcm(const bigint &a,const bigint &b){
    method read (line 220) | void read(const string &s){
    method istream (line 236) | istream &operator>>(istream &stream,bigint &v){
    method ostream (line 243) | ostream &operator<<(ostream &stream,const bigint &v){
    method vll (line 251) | static vll convert_base(const vll &a,ll old_digits,ll new_digits){
    method vll (line 272) | static vll karatsubaMultiply(vll &a,vll &b){
    method bigint (line 310) | bigint operator*(const bigint &v) const{
  function main (line 339) | signed main(){

FILE: tools/cc_hash.cpp
  type cc_hash (line 7) | struct cc_hash{
  function main (line 18) | signed main(){

FILE: tools/chminmax.cpp
  function chmin (line 6) | inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
  function chmax (line 7) | inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
  function main (line 10) | signed main(){

FILE: tools/debug.cpp
  function debug (line 9) | void debug(Ts... ts){
  function main (line 18) | signed main(){

FILE: tools/defaultdict.cpp
  type DefaultDict (line 7) | struct DefaultDict : map<Key, T>{
    method DefaultDict (line 10) | DefaultDict(T val_):val(val_){}
    method T (line 11) | T& operator[](const Key& key){
  function main (line 19) | signed main(){

FILE: tools/dice.cpp
  type Die (line 7) | struct Die{
    method roll (line 15) | void roll(char c){
    method ll (line 37) | ll hash(){
  function makeDice (line 49) | vector<Die<T>> makeDice(Die<T> d){
  function main (line 67) | signed main(){

FILE: tools/drop.cpp
  function drop (line 6) | void drop(const T &x){cout<<x<<endl;exit(0);}
  function main (line 10) | signed main(){

FILE: tools/fastio.cpp
  type FastIO (line 6) | struct FastIO{
    method FastIO (line 7) | FastIO(){
  function main (line 14) | signed main(){

FILE: tools/fixpoint.cpp
  type FixPoint (line 7) | struct FixPoint : F{
    method FixPoint (line 8) | FixPoint(F&& f):F(forward<F>(f)){}
  function MFP (line 15) | inline decltype(auto) MFP(F&& f){
  function main (line 21) | signed main(){

FILE: tools/gridbfs.cpp
  function gridbfs (line 6) | vector< vector<int> >
  function main (line 37) | signed main(){

FILE: tools/int128.cpp
  function __int128_t (line 11) | __int128_t abs128(__int128_t val){return val<0?-val:val;}
  function ostream (line 13) | ostream &operator<<(ostream &os,__int128_t val){
  function istream (line 32) | istream &operator>>(istream &is,__int128_t &val){
  function main (line 44) | signed main(){

FILE: tools/iskado.cpp
  function is_kado (line 7) | bool is_kado(T a,T b,T c){
  function main (line 16) | signed main(){

FILE: tools/trio.cpp
  type trio (line 7) | struct trio{
    method trio (line 11) | trio(T first,U second,V third):
  function make_trio (line 26) | trio<T, U, V> make_trio(T first,U second,V third){
  function main (line 31) | signed main(){

FILE: toptree/base.cpp
  type Vertex (line 6) | struct Vertex{
    method Vertex (line 8) | Vertex():handle(nullptr){}
  type Cluster (line 10) | struct Cluster{
    method Cluster (line 11) | Cluster(){}
    method toggle (line 12) | void toggle(){}
    method Cluster (line 13) | static Cluster compress(Cluster x,Vertex *v,Cluster y){}
    method Cluster (line 14) | static Cluster rake(Cluster x,Cluster y){}
  function main (line 19) | signed main(){

FILE: toptree/distancesum.cpp
  type Vertex (line 12) | struct Vertex{
    method Vertex (line 16) | Vertex(int color=0):handle(nullptr),color(color){}
  type DistanceSum (line 20) | struct DistanceSum{
    type pi (line 21) | struct pi{
      method pi (line 24) | pi():cnt(-1),ptr(nullptr){}
      method pi (line 25) | pi(T cnt,Vertex* ptr):cnt(cnt),ptr(ptr){}
    method DistanceSum (line 33) | DistanceSum(T len=0):len(len),cnt(0),chd(0),ans(0),sum_l(0),sum_r(0){}
    method toggle (line 35) | void toggle(){swap(sum_l,sum_r);}
    method DistanceSum (line 37) | static DistanceSum compress(
    method DistanceSum (line 60) | static DistanceSum rake(const DistanceSum& x,const DistanceSum& y){
  function Vertex (line 81) | Vertex* centroid(TopTree<Vertex, DistanceSum<T>, N> &G, Vertex* v){
    method Vertex (line 16) | Vertex(int color=0):handle(nullptr),color(color){}
  function main (line 130) | signed main(){

FILE: toptree/farthest.cpp
  type Vertex (line 11) | struct Vertex{
    method Vertex (line 13) | Vertex():handle(nullptr){}
  type Farthest (line 17) | struct Farthest{
    type pi (line 18) | struct pi{
      method pi (line 21) | pi():dist(0),idx(-1){}
      method pi (line 22) | pi(T dist,int idx):dist(dist),idx(idx){}
      method pi (line 24) | pi operator+(const T e)const{return pi(dist+e,idx);}
    method Farthest (line 28) | Farthest():lf(0,-1),rg(0,-1),len(0){}
    method Farthest (line 29) | Farthest(T d,int f,int t):lf(d,t),rg(d,f),len(d){}
    method Farthest (line 30) | Farthest(pi md,pi lf,pi rg,T len):md(md),lf(lf),rg(rg),len(len){}
    method toggle (line 31) | void toggle(){swap(lf,rg);}
    method Farthest (line 32) | static Farthest compress(Farthest &x,Vertex*,Farthest &y){
    method Farthest (line 39) | static Farthest rake(Farthest &x,Farthest &y){
  function get_all_farthests (line 45) | vector<int> get_all_farthests(TopTree<Vertex, Farthest<T>, N> &G,Vertex*...
  function main (line 89) | signed main(){

FILE: toptree/steiner.cpp
  type Vertex (line 6) | struct Vertex{
    method Vertex (line 9) | Vertex(int color=0):handle(nullptr),color(color){}
  type SteinerTree (line 13) | struct SteinerTree{
    method SteinerTree (line 15) | SteinerTree(T len=0):con(0),len(len),lf(0),rg(0),md(0),chd(0),ans(0){}
    method toggle (line 16) | void toggle(){return swap(lf,rg);}
    method SteinerTree (line 17) | static SteinerTree compress(SteinerTree x,Vertex* v,SteinerTree y){
    method SteinerTree (line 50) | static SteinerTree rake(SteinerTree x,SteinerTree y){
  function main (line 59) | signed main(){

FILE: toptree/toptree.cpp
  type TopTree (line 7) | struct TopTree{
    type Type (line 8) | enum Type { Compress, Rake, Edge }
    type Node (line 9) | struct Node{
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method Vertex (line 29) | inline Vertex* create(Args ...args){
    method dispose_node (line 38) | inline void dispose_node(Node* t){
    method Node (line 43) | inline Node* get_new_node(){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method Node (line 48) | inline Node* edge(Vertex* u,Cluster w,Vertex* v){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method Node (line 55) | inline Node* compress(Node* l,Node* r){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method Node (line 62) | inline Node* rake(Node* l,Node* r){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method parent_dir (line 69) | int parent_dir(Node* t){
    method parent_dir_ignore_guard (line 78) | int parent_dir_ignore_guard(Node* t){
    method Node (line 86) | inline Node* pushup(Node* const t){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method toggle (line 125) | inline void toggle(Node* t){
    method propagate (line 137) | inline void propagate(Node* t){
    method set_toggle (line 149) | void set_toggle(Node* v){
    method pushdown (line 153) | void pushdown(Node* t){
    method rotate (line 159) | void rotate(Node* t,Node* x,size_t dir){
    method splay (line 174) | void splay(Node* t){
    method Node (line 203) | Node* expose(Node* t){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method Node (line 257) | Node* expose(Vertex* v){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method soft_expose (line 261) | void soft_expose(Vertex* u,Vertex* v){
    method bring (line 280) | void bring(Node* rt){
    method Node (line 323) | Node* link(Vertex* u,Cluster w,Vertex* v){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method cut (line 404) | void cut(Vertex* u,Vertex *v){
    method Node (line 416) | Node* path(Vertex* u,Vertex* v){
      method Node (line 17) | Node(){p=q=nullptr;rev=guard=false;}
    method set_vertex (line 425) | void set_vertex(Vertex* u,Vertex v){
    method set_edge (line 431) | void set_edge(Vertex* u,Vertex* v,const Cluster &w){
    method Cluster (line 438) | Cluster get_path(Vertex* u,Vertex* v){
    method Cluster (line 442) | Cluster get_subtree(Vertex* v){
    method Cluster (line 447) | Cluster get_subtree(Vertex* p,Vertex* v){
  function main (line 462) | signed main(){

FILE: tree/ahu.cpp
  type AHU (line 8) | struct AHU{
    method AHU (line 11) | AHU(int n):G(n){}
    method add_edge (line 13) | void add_edge(int u,int v){
    method dfs (line 18) | int dfs(int v,int p){
    method build (line 29) | int build(int r=0){
  function main (line 37) | signed main(){

FILE: tree/auxiliarytree.cpp
  type AuxiliaryTree (line 12) | struct AuxiliaryTree : LowestCommonAncestor{
    method AuxiliaryTree (line 17) | AuxiliaryTree(int n):super(n),idx(n),T(n){}
    method dfs (line 19) | void dfs(int v,int p,int &pos){
    method build (line 25) | void build(int r=0){
    method add_aux_edge (line 31) | void add_aux_edge(int u,int v){
    method query (line 37) | void query(vector<int> &vs){
    method clear (line 69) | void clear(const vector<int> &ws){
  function main (line 75) | signed main(){

FILE: tree/centroid.cpp
  type Centroid (line 6) | struct Centroid{
    method Centroid (line 9) | Centroid(int n):sz(n,1),dead(n,0),G(n){}
    method add_edge (line 11) | void add_edge(int u,int v){
    method dfs (line 16) | int dfs(int v,int p){
    method find (line 23) | void find(int v,int p,int tmp,vector<int> &cs) {
    method build (line 34) | vector<int> build(int r) {
    method disable (line 42) | void disable(int v){dead[v]=1;}
    method enable (line 43) | void  enable(int v){dead[v]=0;}
    method alive (line 44) | int alive(int v){return !dead[v];}
  function main (line 48) | signed main(){

FILE: tree/construct_from_distances_to_farthest_vertex.cpp
  function construct_from_distances_to_farthest_vertex (line 6) | vector< vector<int> >
  class TreeDistanceConstruction (line 61) | class TreeDistanceConstruction {
    method construct (line 63) | vector<int> construct(vector<int> ds) {

FILE: tree/diameterforedge.cpp
  type DiameterForEdge (line 7) | struct DiameterForEdge{
    method DiameterForEdge (line 11) | DiameterForEdge(int n):dp(n),ps(n),G(n){}
    method add_edge (line 12) | void add_edge(int u,int v,T c){
    method dfs (line 16) | void dfs(int v,int p,int &s){
    method endPoints (line 27) | pair<int, int> endPoints(){
    method T (line 34) | T build(){
    method restore (line 38) | vector<int> restore(){
    method distance (line 47) | vector<T> distance(int v){
    method farthest (line 51) | vector<T> farthest(){
  function YAHOO2019_FINAL_B (line 68) | signed YAHOO2019_FINAL_B(){
  function main (line 115) | signed main(){

FILE: tree/diameterforvertex.cpp
  type DiameterForVertex (line 7) | struct DiameterForVertex{
    method DiameterForVertex (line 10) | DiameterForVertex(int n):dp(n),G(n){}
    method DiameterForVertex (line 11) | DiameterForVertex(vector<T> vs):vs(vs),dp(vs.size()),G(vs.size()){}
    method add_edge (line 13) | void add_edge(int u,int v){
    method dfs (line 18) | void dfs(int v,int p,int &s){
    method T (line 29) | T build(){
    method T (line 37) | T build(vector<T> us){
  function ARC097_F (line 47) | signed ARC097_F(){
  function main (line 109) | signed main(){

FILE: tree/eulertourforbfs.cpp
  type EulerTourForBFS (line 12) | struct EulerTourForBFS : LevelAncestor{
    method EulerTourForBFS (line 16) | EulerTourForBFS(int n):super(n),ls(n),H(n){}
    method build (line 20) | void build(int r=0){
    method idx (line 36) | int idx(int v){return ls[v];}
    method find (line 38) | int find(int v,int d,int a){
    method exec (line 50) | void exec(int v,int d,F f){
  function main (line 60) | signed main(){

FILE: tree/eulertourforedge.cpp
  class EulerTourForEdge (line 6) | class EulerTourForEdge{
    method dfs (line 10) | void dfs(int v,int p,int d){
    method EulerTourForEdge (line 24) | EulerTourForEdge(int n):
    method add_edge (line 27) | void add_edge(int u,int v){
    method build (line 32) | void build(int r=0){
    method child (line 41) | int child(int u,int v){
    method bottom (line 45) | int bottom(int e){
    method query (line 51) | void query(int u,int v,F f){
    method update (line 57) | void update(int v,T x,G g){
  function main (line 64) | signed main(){

FILE: tree/eulertourforvertex.cpp
  class EulerTourForVertex (line 6) | class EulerTourForVertex{
    method dfs (line 11) | void dfs(int v,int p){
    method EulerTourForVertex (line 20) | EulerTourForVertex(int n):ls(n),rs(n),G(n){}
    method add_edge (line 22) | void add_edge(int u,int v){
    method build (line 27) | void build(int r=0){
    method idx (line 32) | int idx(int v){return ls[v];}
    method exec (line 35) | void exec(int v,F f){
  function main (line 41) | signed main(){

FILE: tree/heavylightdecomposition.cpp
  class HLD (line 6) | class HLD{
    method dfs_sz (line 8) | void dfs_sz(int v) {
    method dfs_hld (line 20) | void dfs_hld(int v,int &pos) {
    method HLD (line 37) | HLD(int n):G(n),vid(n,-1),nxt(n),sub(n,1),par(n,-1),inv(n){}
    method add_edge (line 39) | void add_edge(int u,int v) {
    method build (line 44) | void build(int r=0) {
    method lca (line 51) | int lca(int u,int v){
    method for_each (line 60) | void for_each(int u,int v,const F& f) {
    method for_each_edge (line 70) | void for_each_edge(int u,int v,const F& f) {
  function main (line 85) | signed main(){

FILE: tree/lca.cpp
  type LCA (line 6) | struct LCA{
    method LCA (line 13) | LCA(int n):
    method add_edge (line 16) | void add_edge(int u,int v){
    method dfs (line 21) | void dfs(int v,int p,int d){
    method comp (line 49) | inline int comp(int i,int j){return E[i]<E[j]?i:j;}
    method comp (line 50) | inline int comp(int i,int j,int k){return comp(comp(i,j),k);}
    method build (line 52) | void build(int r=0){
    method cs (line 84) | inline int cs(int a,int b){
    method es (line 89) | inline int es(int i,int l,int r){
    method ls (line 95) | inline int ls(int i,int l){
    method rs (line 101) | inline int rs(int j,int r){
    method rmq (line 107) | inline int rmq(int l,int r){
    method lca (line 114) | int lca(int l,int r){
  function main (line 125) | signed main(){

FILE: tree/levelancestor.cpp
  type LevelAncestor (line 6) | struct LevelAncestor{
    method LevelAncestor (line 9) | LevelAncestor(int n):
    method add_edge (line 17) | void add_edge(int u,int v){
    method dfs (line 22) | void dfs(int v,int p,int d,int f){
    method build (line 47) | void build(int r=0){
    method lca (line 71) | int lca(int u,int v){
    method distance (line 88) | int distance(int u,int v){
    method up (line 92) | int up(int v,int d){
    method next (line 100) | int next(int u,int v){
  function main (line 109) | signed main(){

FILE: tree/lowestcommonancestor.cpp
  type LowestCommonAncestor (line 6) | struct LowestCommonAncestor{
    method LowestCommonAncestor (line 10) | LowestCommonAncestor(int n):G(n),dep(n){
    method add_edge (line 16) | void add_edge(int u,int v){
    method dfs (line 21) | void dfs(int v,int p,int d){
    method build (line 28) | void build(int r=0){
    method lca (line 37) | int lca(int u,int v){
    method distance (line 52) | int distance(int u,int v){
  function main (line 58) | signed main(){

FILE: tree/mo_on_tree.cpp
  type MoOnTree (line 12) | struct MoOnTree{
    method MoOnTree (line 19) | MoOnTree(int n,int width,F expand,F shrink):
    method add_edge (line 22) | void add_edge(int u,int v){
    method add_query (line 26) | void add_query(int u,int v){
    method build (line 29) | void build(){
    method process (line 46) | int process(){return mo->process();}
  function main (line 51) | signed main(){

FILE: tree/rerooting.cpp
  type ReRooting (line 8) | struct ReRooting{
    type Node (line 9) | struct Node{
      method Node (line 12) | Node(int to,Edge data):to(to),data(data){}
    method ReRooting (line 27) | ReRooting(int n,const Fold fold,const Lift lift,const T id):
    method add_edge (line 30) | void add_edge(int u,int v,Edge d,Edge e){
    method add_edge (line 35) | void add_edge(int u,int v,Edge d){add_edge(u,v,d,d);}
    method T (line 38) | T dfs(int v,int k){
    method search (line 53) | int search(vector<Node> &vs,int idx){
    method build (line 57) | vector<T> build(){
    method T (line 79) | T subtree(int v,int p){
  function main (line 88) | signed main(){

FILE: tree/sack.cpp
  type Sack (line 7) | struct Sack{
    method Sack (line 14) | Sack(int n,F expand,F shrink,F query):
    method add_edge (line 18) | void add_edge(int u,int v){
    method add_query (line 23) | void add_query(int v,int k){
    method add (line 27) | void add(int v,int p,int x){
    method dfs (line 34) | void dfs(int v=0,int p=-1,bool k=0){
    method build (line 47) | void build(int v=0,int p=-1){
  function main (line 60) | signed main(){

FILE: vector/compress.cpp
  function V (line 8) | V compress(V vs){
  function dict (line 14) | map<T, int> dict(const vector<T> &vs){
  function dict (line 20) | map<char, int> dict(const string &s){
  function compressed (line 24) | vector<T> compressed(vector<T> vs){
  function main (line 32) | signed main(){

FILE: vector/fusion.cpp
  function fusion (line 8) | vector<T> fusion(vector<T> bs,Ts... ts){
  function main (line 15) | signed main(){

FILE: vector/identity.cpp
  function identity (line 7) | vector<int> identity(int n){
  function main (line 14) | signed main(){

FILE: vector/inversion.cpp
  function inversion (line 13) | long long inversion(vector<T> vs){
  function main (line 27) | signed main(){

FILE: vector/multi.cpp
  function make_v (line 7) | vector<T> make_v(size_t a){return vector<T>(a);}
  function make_v (line 10) | auto make_v(size_t a,Ts... ts){
  function fill_v (line 15) | typename enable_if<is_same<T, U>::value!=0>::type
  function fill_v (line 19) | typename enable_if<is_same<T, U>::value==0>::type
  function main (line 26) | signed main(){

FILE: vector/near.cpp
  function add (line 8) | vector<T> add(vector<T> vs,vector<T> as){
  function add (line 15) | vector<T> add(vector<T> vs,U a){
  function mul (line 20) | vector<T> mul(vector<T> vs,vector<T> as){
  function mul (line 27) | vector<T> mul(vector<T> vs,U a){
  function near (line 32) | vector<T> near(vector<T> vs,Ts... ts){
  function main (line 43) | signed main(){

FILE: vector/powers.cpp
  function powers (line 9) | vector<T> powers(int n,T x){
  function main (line 16) | signed main(){

FILE: vector/reversed.cpp
  function reversed (line 8) | vector<T> reversed(vector<T> vs){
  function main (line 14) | signed main(){

FILE: vector/runlength.cpp
  function runlength (line 8) | decltype(auto) runlength(vector<T> vs){
  function main (line 20) | signed main(){

FILE: vector/sorted.cpp
  function sorted (line 8) | vector<T> sorted(vector<T> vs){
  function main (line 14) | signed main(){

FILE: vector/zip.cpp
  function zip (line 8) | decltype(auto) zip(vector<Ts>... args){
  function main (line 17) | signed main(){

[
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 247,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the b"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 595,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Is your fea"
  },
  {
    "path": ".github/workflows/sanitize.yml",
    "chars": 502,
    "preview": "name: sanitize\n\non: push\n\njobs:\n  build-sanitize:\n    runs-on: ubuntu-latest\n\n    steps:\n    - uses: actions/checkout@v1"
  },
  {
    "path": ".github/workflows/verify.yml",
    "chars": 551,
    "preview": "name: verify\n\non: push\n\njobs:\n  build:\n    runs-on: ubuntu-latest\n\n    permissions:\n      contents: write\n\n    steps:\n  "
  },
  {
    "path": ".gitignore",
    "chars": 3569,
    "preview": "#Do NOT edit this file manually. Use ./.gitignore_gen.sh > .gitignore\n### https://raw.github.com/github/gitignore/07c730"
  },
  {
    "path": ".gitignore_gen.sh",
    "chars": 295,
    "preview": "#!/bin/bash\necho \"#Do NOT edit this file manually. Use ./.gitignore_gen.sh > .gitignore\"\ngibo dump Vim Emacs C C++ Pytho"
  },
  {
    "path": ".verify-helper/config.toml",
    "chars": 91,
    "preview": "[[languages.cpp.environments]]\nCXX = \"g++\"\n\n[[languages.cpp.environments]]\nCXX = \"clang++\"\n"
  },
  {
    "path": ".verify-helper/docs/_config.yml",
    "chars": 102,
    "preview": "exclude: [\"./heuristic/\", \"./leetcode/\", \"./test/aoj/2432.ignore.cpp\", \"test/aoj/GRL_4_B.ignore.cpp\"]\n"
  },
  {
    "path": ".verify-helper/local.toml",
    "chars": 43,
    "preview": "[[languages.cpp.environments]]\nCXX = \"g++\"\n"
  },
  {
    "path": ".verify-helper/sanitize.toml",
    "chars": 289,
    "preview": "[[languages.cpp.environments]]\nCXX = \"g++\"\nCXXFLAGS = [\"-std=c++17\", \"-Wall\", \"-g\", \"-DSANITIZE\", \"-fsanitize=undefined\""
  },
  {
    "path": ".verify-helper/timestamps.local.json.20201106",
    "chars": 22093,
    "preview": "{\n\"test/aoj/0109.test.cpp\": \"2020-10-27 13:22:02 +0900\",\n\"test/aoj/0168.test.cpp\": \"2020-10-13 16:41:33 +0900\",\n\"test/ao"
  },
  {
    "path": ".verify-helper/timestamps.local.json.20210324",
    "chars": 23576,
    "preview": "{\n\"test/aoj/0109.test.cpp\": \"2020-12-19 16:43:05 +0900\",\n\"test/aoj/0168.test.cpp\": \"2020-12-20 13:43:25 +0900\",\n\"test/ao"
  },
  {
    "path": ".verify-helper/timestamps.remote.json",
    "chars": 24434,
    "preview": "{\n\"test/aoj/0109.test.cpp\": \"2021-09-10 23:35:46 +0900\",\n\"test/aoj/0168.test.cpp\": \"2020-12-20 13:43:34 +0900\",\n\"test/ao"
  },
  {
    "path": "README.md",
    "chars": 350,
    "preview": "# library\n\n[![Actions Status](https://github.com/beet-aizu/library/workflows/verify/badge.svg)](https://github.com/beet-"
  },
  {
    "path": "algorithm/knuthyao.cpp",
    "chars": 788,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// f(i,l) + f(j,k) >= f(i,k"
  },
  {
    "path": "algorithm/largestrectangle.cpp",
    "chars": 655,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nT larg"
  },
  {
    "path": "algorithm/mo.cpp",
    "chars": 1233,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct Mo{\n  using F = func"
  },
  {
    "path": "algorithm/monotoneminima.cpp",
    "chars": 743,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nnamespace MonotoneMinima{\n "
  },
  {
    "path": "algorithm/offlineonline.cpp",
    "chars": 1286,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n// https://qiita.com/tmaehara/items/0687af2"
  },
  {
    "path": "algorithm/optimalbinarytree.cpp",
    "chars": 1820,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../datastructure/"
  },
  {
    "path": "algorithm/parallelbinarysearch.cpp",
    "chars": 817,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// n questions, q operation"
  },
  {
    "path": "algorithm/partialsum.cpp",
    "chars": 605,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(n sqrt(n) / w)\n// w: w"
  },
  {
    "path": "bbst/pb_ds_tree.cpp",
    "chars": 592,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n#include<ext/pb_ds/assoc_con"
  },
  {
    "path": "bbst/rbst/data/array.cpp",
    "chars": 1265,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "bbst/rbst/data/dual.cpp",
    "chars": 1169,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename E, typena"
  },
  {
    "path": "bbst/rbst/data/lazy.cpp",
    "chars": 2044,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T, typena"
  },
  {
    "path": "bbst/rbst/data/ushi.cpp",
    "chars": 1606,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T, typena"
  },
  {
    "path": "bbst/rbst/impl/basic.cpp",
    "chars": 1030,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../rbst.cpp\"\n#und"
  },
  {
    "path": "bbst/rbst/impl/persistent.cpp",
    "chars": 3970,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../rbst.cpp\"\n#und"
  },
  {
    "path": "bbst/rbst/rbst.cpp",
    "chars": 4013,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename Impl, typ"
  },
  {
    "path": "bflow/capacityscaling.cpp",
    "chars": 5009,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(m^2 \\log m \\log U)\n// "
  },
  {
    "path": "clean.sh",
    "chars": 103,
    "preview": "#!/bin/bash\nfind . -name '*~' | xargs rm -v\nfind . -name 'a.out' | grep -v verify-helper | xargs rm -v\n"
  },
  {
    "path": "combinatorics/bell.cpp",
    "chars": 623,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"enumeration.cpp\"\n"
  },
  {
    "path": "combinatorics/bernoulli.cpp",
    "chars": 787,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"enumeration.cpp\"\n"
  },
  {
    "path": "combinatorics/enumeration.cpp",
    "chars": 1284,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename M_>\nclas"
  },
  {
    "path": "combinatorics/partition.cpp",
    "chars": 822,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"enumeration.cpp\"\n"
  },
  {
    "path": "combinatorics/partitiontable.cpp",
    "chars": 642,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename M>\nstruc"
  },
  {
    "path": "combinatorics/stirling1st.cpp",
    "chars": 1299,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"enumeration.cpp\"\n"
  },
  {
    "path": "combinatorics/stirling2nd.cpp",
    "chars": 771,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"enumeration.cpp\"\n"
  },
  {
    "path": "combinatorics/surjection.cpp",
    "chars": 512,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"enumeration.cpp\"\n"
  },
  {
    "path": "convexhulltrick/convexhulltrick.cpp",
    "chars": 4603,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nenum Objective{\n  MINIMIZE ="
  },
  {
    "path": "convexhulltrick/linecontainer.cpp",
    "chars": 1645,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nenum Objective{\n  MAXIMIZE ="
  },
  {
    "path": "convexhulltrick/segmentcontainer.cpp",
    "chars": 1692,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nenum Objective{\n  MINIMIZE "
  },
  {
    "path": "convexhulltrick/withindex.cpp",
    "chars": 2983,
    "preview": "#include <bits/stdc++.h>\nusing namespace std;\n//BEGIN CUT HERE\n// index siyou kimattenai\ntemplate <typename T,bool isMin"
  },
  {
    "path": "convolution/arbitrarymod.cpp",
    "chars": 1536,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"fastfouriertransf"
  },
  {
    "path": "convolution/bitwise/and.cpp",
    "chars": 303,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nnamespace bitwise_and{\n  au"
  },
  {
    "path": "convolution/bitwise/fwht.cpp",
    "chars": 462,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n// https://kazuma8128.hatenablog.com/entry/2"
  },
  {
    "path": "convolution/bitwise/or.cpp",
    "chars": 302,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nnamespace bitwise_or{\n  aut"
  },
  {
    "path": "convolution/bitwise/xor.cpp",
    "chars": 417,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nnamespace bitwise_xor{\n  au"
  },
  {
    "path": "convolution/convolution2D.cpp",
    "chars": 1118,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T,typenam"
  },
  {
    "path": "convolution/divisor.cpp",
    "chars": 1460,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n// https://noshi91.hatenablog.com/entry/2019"
  },
  {
    "path": "convolution/fastfouriertransform.cpp",
    "chars": 2338,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nnamespace FFT{\n  using dbl ="
  },
  {
    "path": "convolution/garner.cpp",
    "chars": 2052,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../mod/mint.cpp\"\n"
  },
  {
    "path": "convolution/naive.cpp",
    "chars": 466,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(N M)\ntemplate<typename"
  },
  {
    "path": "convolution/numbertheoretictransform.cpp",
    "chars": 2205,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../mod/mint.cpp\"\n"
  },
  {
    "path": "datastructure/BIT2D.cpp",
    "chars": 762,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "datastructure/absolutesum.cpp",
    "chars": 1992,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "datastructure/binaryindexedtree.cpp",
    "chars": 953,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename T>\nclass"
  },
  {
    "path": "datastructure/binarytrie.cpp",
    "chars": 4395,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T,size_t "
  },
  {
    "path": "datastructure/bitvector.cpp",
    "chars": 1580,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\n// half open interval [l, "
  },
  {
    "path": "datastructure/cartesiantree.cpp",
    "chars": 592,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename T>\nvecto"
  },
  {
    "path": "datastructure/cumulativesum.cpp",
    "chars": 456,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "datastructure/disjointsparsetable.cpp",
    "chars": 1896,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "datastructure/kdtree.cpp",
    "chars": 1782,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "datastructure/pb_ds_cc_hash_table.cpp",
    "chars": 345,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n#include <ext/pb_ds/assoc_co"
  },
  {
    "path": "datastructure/prioritysum.cpp",
    "chars": 4735,
    "preview": "#include<bits/stdc++.h>\nusing namespace std;\n//BEGIN CUT HERE\n// return sum of top K element (default: maximum)\ntemplate"
  },
  {
    "path": "datastructure/quickfind.cpp",
    "chars": 760,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct QuickFind{\n  vector<"
  },
  {
    "path": "datastructure/radixheap.cpp",
    "chars": 1082,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// prohibited to push an ele"
  },
  {
    "path": "datastructure/rangeslide.cpp",
    "chars": 907,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T, typenam"
  },
  {
    "path": "datastructure/rotcev.cpp",
    "chars": 868,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// no resize() because it i"
  },
  {
    "path": "datastructure/skewheap.cpp",
    "chars": 2508,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T, typena"
  },
  {
    "path": "datastructure/slidingwindowaggregation.cpp",
    "chars": 3527,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T,typename"
  },
  {
    "path": "datastructure/slope.cpp",
    "chars": 2635,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// https://maspypy.com/slop"
  },
  {
    "path": "datastructure/sparsetable.cpp",
    "chars": 774,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "datastructure/unionfind.cpp",
    "chars": 683,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct UnionFind{\n  int num"
  },
  {
    "path": "datastructure/waveletmatrix.cpp",
    "chars": 4331,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\nstruct FullyIndexableDicti"
  },
  {
    "path": "datastructure/weightedunionfind.cpp",
    "chars": 834,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate <typename T>\nstruct"
  },
  {
    "path": "docs/bflow/capacityscaling.md",
    "chars": 595,
    "preview": "---\ntitle: Minimum Cost Flow with Capacity Scaling\ndocumentation_of: //bflow/capacityscaling.cpp\n---\n\n## `INF` の決め方\n### "
  },
  {
    "path": "docs/datastructure/binaryindexedtree.md",
    "chars": 491,
    "preview": "---\ntitle: Binary Indexed Tree\ndocumentation_of: //datastructure/binaryindexedtree.cpp\n---\n\n## できること\n- `add(i,a)`\n-- $v_"
  },
  {
    "path": "docs/datastructure/waveletmatrix.md",
    "chars": 556,
    "preview": "---\ntitle: Wavelet Matrix\ndocumentation_of: //datastructure/waveletmatrix.cpp\n---\n\n## できること\n- `rank(v,k)`\n-- $\\lbrack 0,"
  },
  {
    "path": "docs/graph/rangetorange.md",
    "chars": 273,
    "preview": "---\ntitle: Range to Range\ndocumentation_of: //graph/rangetorange.cpp\n---\n\n## できること\n区間から区間に向けて辺を貼る\n\n## 注意\n元のグラフでの頂点 $v$ は"
  },
  {
    "path": "docs/maxflow/dinic.md",
    "chars": 256,
    "preview": "---\ntitle: 最大流\ndocumentation_of: //maxflow/dinic.cpp\n---\n\n## 解説記事\n[Dinic 法と, その注意点](https://topcoder-g-hatena-ne-jp.jag-"
  },
  {
    "path": "docs/maxflow/fordfulkerson.md",
    "chars": 76,
    "preview": "---\ntitle: 最大流 (計算量が流量依存)\ndocumentation_of: //maxflow/fordfulkerson.cpp\n---\n"
  },
  {
    "path": "docs/maxflow/leastflow.md",
    "chars": 146,
    "preview": "---\ntitle: 最小流量制限付き最大流\ndocumentation_of: //maxflow/leastflow.cpp\n---\n\n## 解説記事\n[最小流量制限付き最大流](https://snuke.hatenablog.com"
  },
  {
    "path": "docs/maxflow/twocommodity.md",
    "chars": 149,
    "preview": "---\ntitle: 最大二品種流\ndocumentation_of: //maxflow/twocommodity.cpp\n---\n\n## 解説記事\n[多品種流の話](http://www.kurims.kyoto-u.ac.jp/~ke"
  },
  {
    "path": "docs/mincostflow/negativeedge.md",
    "chars": 151,
    "preview": "---\ntitle: 最小費用流の負辺除去\ndocumentation_of: //mincostflow/negativeedge.cpp\n---\n\n## 解説記事\n[最小費用流の負辺除去](https://snuke.hatenablo"
  },
  {
    "path": "docs/mincostflow/primaldual.md",
    "chars": 517,
    "preview": "---\ntitle: 最小費用流\ndocumentation_of: //mincostflow/primaldual.cpp\n---\n\n## 解説記事\n[最小費用流の双対について](https://beet-aizu.hatenablog"
  },
  {
    "path": "docs/segtree/basic/lazy.md",
    "chars": 171,
    "preview": "---\ntitle: 遅延伝播セグメント木\ndocumentation_of: //segtree/basic/lazy.cpp\n---\n\n## 解説記事\n[遅延伝播セグメント木について（旧：遅延評価セグメント木について）](https:/"
  },
  {
    "path": "docs/string/longestcommonprefix.md",
    "chars": 300,
    "preview": "---\ntitle: Longest Common Prefix\ndocumentation_of: //string/longestcommonprefix.cpp\n---\n\n## できること\n- `query(a,b)`\n-- $S$ "
  },
  {
    "path": "docs/string/suffixarray.md",
    "chars": 334,
    "preview": "---\ntitle: Suffix Array\ndocumentation_of: //string/suffixarray.cpp\n---\n\n## できること\n- `sa[i]` : $S$ の末尾辞の中で $i$ 番目に小さいものの位置"
  },
  {
    "path": "docs/test/aoj/0438.test.md",
    "chars": 91,
    "preview": "---\ntitle: test find_by_order, order_of_key\ndocumentation_of: //test/aoj/0438.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/0563.test.md",
    "chars": 77,
    "preview": "---\ntitle: test find_by_order\ndocumentation_of: //test/aoj/0563.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/1549.test.md",
    "chars": 74,
    "preview": "---\ntitle: test succ, pred\ndocumentation_of: //test/aoj/1549.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/1595.toptree.test.md",
    "chars": 91,
    "preview": "---\ntitle: Farthest (without index)\ndocumentation_of: //test/aoj/1549.toptree.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2290.test.md",
    "chars": 79,
    "preview": "---\ntitle: initialize potential\ndocumentation_of: //test/aoj/2290.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2313.test.md",
    "chars": 72,
    "preview": "---\ntitle: test link cut\ndocumentation_of: //test/aoj/2313.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2636.test.md",
    "chars": 71,
    "preview": "---\ntitle: Distance Sum\ndocumentation_of: //test/aoj/2636.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2667.test.md",
    "chars": 81,
    "preview": "---\ntitle: Path & Subtree Queries\ndocumentation_of: //test/aoj/2667.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2679.test.md",
    "chars": 79,
    "preview": "---\ntitle: lexicographical cost\ndocumentation_of: //test/aoj/2679.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2711.test.md",
    "chars": 67,
    "preview": "---\ntitle: test lcp\ndocumentation_of: //test/aoj/2711.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2725.linecontainer.test.md",
    "chars": 94,
    "preview": "---\ntitle: test MaxLineContainer\ndocumentation_of: //test/aoj/2725.linecontainer.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/2890.test.md",
    "chars": 76,
    "preview": "---\ntitle: test order_of_key\ndocumentation_of: //test/aoj/2890.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/3069.test.md",
    "chars": 80,
    "preview": "---\ntitle: test MinLineContainer\ndocumentation_of: //test/aoj/3069.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/3112.test.md",
    "chars": 69,
    "preview": "---\ntitle: test query\ndocumentation_of: //test/aoj/3112.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/3117.test.md",
    "chars": 76,
    "preview": "---\ntitle: test order_of_key\ndocumentation_of: //test/aoj/3117.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/3143.test.md",
    "chars": 80,
    "preview": "---\ntitle: Farthest (with index)\ndocumentation_of: //test/aoj/3143.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/DSL_2_F.test.md",
    "chars": 71,
    "preview": "---\ntitle: RMQ & RUQ\ndocumentation_of: //test/aoj/DSL_2_F.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/DSL_2_H.test.md",
    "chars": 71,
    "preview": "---\ntitle: RMQ & RAQ\ndocumentation_of: //test/aoj/DSL_2_H.test.cpp\n---\n"
  },
  {
    "path": "docs/test/aoj/DSL_2_I.test.md",
    "chars": 71,
    "preview": "---\ntitle: RSQ & RUQ\ndocumentation_of: //test/aoj/DSL_2_I.test.cpp\n---\n"
  },
  {
    "path": "docs/test/yosupo/range_kth_smallest.test.md",
    "chars": 90,
    "preview": "---\ntitle: test rquantile\ndocumentation_of: //test/yosupo/range_kth_smallest.test.cpp\n---\n"
  },
  {
    "path": "docs/test/yukicoder/1732.test.md",
    "chars": 78,
    "preview": "---\ntitle: test quantile\ndocumentation_of: //test/yukicoder/1732.test.cpp\n---\n"
  },
  {
    "path": "docs/test/yukicoder/1937.test.md",
    "chars": 79,
    "preview": "---\ntitle: test rangefreq\ndocumentation_of: //test/yukicoder/1937.test.cpp\n---\n"
  },
  {
    "path": "docs/test/yukicoder/3267.test.md",
    "chars": 84,
    "preview": "---\ntitle: test GCDConvolution\ndocumentation_of: //test/yukicoder/3267.test.cpp\n---\n"
  },
  {
    "path": "docs/test/yukicoder/3453.test.md",
    "chars": 85,
    "preview": "---\ntitle: Minimum Steiner Tree\ndocumentation_of: //test/yukicoder/3453.test.cpp\n---\n"
  },
  {
    "path": "docs/test/yukicoder/7107.test.md",
    "chars": 84,
    "preview": "---\ntitle: test LCMConvolution\ndocumentation_of: //test/yukicoder/7107.test.cpp\n---\n"
  },
  {
    "path": "docs/toptree/toptree.md",
    "chars": 221,
    "preview": "---\ntitle: Top Tree\ndocumentation_of: //toptree/toptree.cpp\n---\n\n## 解説記事\n[Toptree 導入編](https://niuez.hatenablog.com/entr"
  },
  {
    "path": "docs/tree/ahu.md",
    "chars": 161,
    "preview": "---\ntitle: 根付き木の同型性判定\ndocumentation_of: //tree/ahu.cpp\n---\n\n## できること\n与えられた根付き木の決定的なハッシュ値を求める\n\n一般の木について同型性判定を行う場合は、まず木の中心"
  },
  {
    "path": "docs/tree/auxiliarytree.md",
    "chars": 398,
    "preview": "---\ntitle: Auxiliary Tree\ndocumentation_of: //tree/auxiliarytree.cpp\n---\n\n## できること\n与えられた木の頂点の部分集合に関して、その頂点を全て含むような最小の木を構"
  },
  {
    "path": "docs/tree/heavylightdecomposition.md",
    "chars": 683,
    "preview": "---\ntitle: Heavy Light Decomposition\ndocumentation_of: //tree/heavylightdecomposition.cpp\n---\n\n## できること\n\nHL分解では、木（あるいは森 "
  },
  {
    "path": "docs/tree/rerooting.md",
    "chars": 673,
    "preview": "---\ntitle: ReRooting\ndocumentation_of: //tree/rerooting.cpp\n---\n\n## できること\n全ての頂点について、その頂点を根としたときの木DPの結果を求める\n\nある頂点を根としたときの"
  },
  {
    "path": "docs/tree/sack.md",
    "chars": 547,
    "preview": "---\ntitle: Sack (dsu on tree)\ndocumentation_of: //tree/sack.cpp\n---\n\n## できること\n部分木に対するクエリを処理できる\n\nunordered 系を使ったマージテクより定数"
  },
  {
    "path": "formalpowerseries/998244353.cpp",
    "chars": 576,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../mod/mint.cpp\"\n"
  },
  {
    "path": "formalpowerseries/base.cpp",
    "chars": 1910,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/diff.cpp",
    "chars": 457,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/div.cpp",
    "chars": 649,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/exp.cpp",
    "chars": 588,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/integral.cpp",
    "chars": 510,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/inv.cpp",
    "chars": 527,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/log.cpp",
    "chars": 493,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/mod.cpp",
    "chars": 570,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/pow.cpp",
    "chars": 857,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/shift.cpp",
    "chars": 670,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "formalpowerseries/sqrt.cpp",
    "chars": 585,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../combinatorics/"
  },
  {
    "path": "geometry/3D/geometry3D.cpp",
    "chars": 5844,
    "preview": "#include <bits/stdc++.h>\nusing namespace std;\n//BEGIN CUT HERE\n\n#define EPS (1e-10)\n#define equals(a,b) (fabs((a)-(b)) <"
  },
  {
    "path": "geometry/argsort.cpp",
    "chars": 712,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// (-pi, pi], atan2(0, 0) ="
  },
  {
    "path": "geometry/geometry.cpp",
    "chars": 15607,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n\n#define equals(a,b) (fabs("
  },
  {
    "path": "geometry/projectilemotion.cpp",
    "chars": 671,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// throw from origin to (x,"
  },
  {
    "path": "graph/arborescence_edmond.cpp",
    "chars": 1348,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"stronglyconnectedc"
  },
  {
    "path": "graph/arborescence_tarjan.cpp",
    "chars": 3633,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "graph/bellmanford.cpp",
    "chars": 1339,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct "
  },
  {
    "path": "graph/bfs.cpp",
    "chars": 496,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nvector<int> bfs(int s,vecto"
  },
  {
    "path": "graph/bipartitedecomposition.cpp",
    "chars": 993,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(n)\nstruct BipartiteDec"
  },
  {
    "path": "graph/chromatic.cpp",
    "chars": 1187,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nint chromatic(vector< vector"
  },
  {
    "path": "graph/cycle.cpp",
    "chars": 1051,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<bool directed>\nstr"
  },
  {
    "path": "graph/dijkstra.cpp",
    "chars": 1195,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "graph/dominatortree.cpp",
    "chars": 1839,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct DominatorTree{\n  stru"
  },
  {
    "path": "graph/dynamicconnectivity.cpp",
    "chars": 2085,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct PersistentUnionFind{"
  },
  {
    "path": "graph/girth.cpp",
    "chars": 1391,
    "preview": "#include <bits/stdc++.h>\nusing namespace std;\n//BEGIN CUT HERE\n// size of minimum cycle in undirected graph\nint girth(ve"
  },
  {
    "path": "graph/grid.cpp",
    "chars": 692,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename F>\nstruct"
  },
  {
    "path": "graph/independentset.cpp",
    "chars": 1357,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct IndependentSet{\n  in"
  },
  {
    "path": "graph/kruskal.cpp",
    "chars": 840,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../datastructure/"
  },
  {
    "path": "graph/lowlink.cpp",
    "chars": 5183,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct LowLink{\n  int n,pos"
  },
  {
    "path": "graph/manhattanmst.cpp",
    "chars": 1089,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nvector"
  },
  {
    "path": "graph/multipleeuleriantrail.cpp",
    "chars": 1251,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// no muliple edge\ntemplate<"
  },
  {
    "path": "graph/nicetree.cpp",
    "chars": 7173,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct NiceTree{\n  vector< "
  },
  {
    "path": "graph/rangetorange.cpp",
    "chars": 1231,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n// https://lorent-kyopro.hatenablog.com/ent"
  },
  {
    "path": "graph/semikernel.cpp",
    "chars": 1188,
    "preview": "#include<bits/stdc++.h>\nusing namespace std;\n//BEGIN CUT HERE\n// https://link.springer.com/content/pdf/10.1007%2FBFb0066"
  },
  {
    "path": "graph/stronglyconnectedcomponent.cpp",
    "chars": 1253,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct SCC{\n  vector< vector"
  },
  {
    "path": "graph/topologicalsort.cpp",
    "chars": 832,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct TopologicalSort{\n  v"
  },
  {
    "path": "graph/triangle.cpp",
    "chars": 905,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct Triangle{\n  // if no"
  },
  {
    "path": "graph/twoedgeconnectedcomponents.cpp",
    "chars": 1719,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// work with multigraph\nstr"
  },
  {
    "path": "graph/twosatisfiability.cpp",
    "chars": 3275,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"stronglyconnected"
  },
  {
    "path": "graph/voronoiminimumspanningtree.cpp",
    "chars": 2139,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "heuristic/timer.cpp",
    "chars": 1038,
    "preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n/**\n * @ignore\n */\n//BEGIN CUT HERE\nusing i16 = int16_t;\nusing i32 = int32"
  },
  {
    "path": "heuristic/xorshift.cpp",
    "chars": 399,
    "preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n/**\n * @ignore\n */\n\n//BEGIN CUT HERE\nuint32_t xor128(){\n  static uint32_t "
  },
  {
    "path": "includes/formalpowerseries.h",
    "chars": 675,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\n#define call_from_test\n#in"
  },
  {
    "path": "io/precision.cpp",
    "chars": 256,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nstruct Precision{\n  Precisi"
  },
  {
    "path": "io/single.cpp",
    "chars": 291,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename T=int>\nv"
  },
  {
    "path": "io/space.cpp",
    "chars": 315,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename T>\nvoid "
  },
  {
    "path": "io/tuple.cpp",
    "chars": 610,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\ntemplate<typename TV, cons"
  },
  {
    "path": "io/yesno.cpp",
    "chars": 395,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n\n//BEGIN CUT HERE\nstruct BoolPrinter{\n  cons"
  },
  {
    "path": "leetcode/treenode.cpp",
    "chars": 753,
    "preview": "#include<bits/stdc++.h>\nusing namespace std;\n\n/**\n * @ignore\n */\n\n//BEGIN CUT HERE\n\nstruct TreeNode {\n  int val;\n  TreeN"
  },
  {
    "path": "linearalgebra/binarymatrix.cpp",
    "chars": 2228,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nconst int MAX = 2002;\nusing"
  },
  {
    "path": "linearalgebra/matrix.cpp",
    "chars": 4590,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename K>\nstruct "
  },
  {
    "path": "linearalgebra/squarematrix.cpp",
    "chars": 1444,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename R, size_t "
  },
  {
    "path": "linearalgebra/tree_theorem.cpp",
    "chars": 2832,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"matrix.cpp\"\n#incl"
  },
  {
    "path": "linkcuttree/base.cpp",
    "chars": 2683,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename Node, siz"
  },
  {
    "path": "linkcuttree/farthest.cpp",
    "chars": 2738,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"base.cpp\"\n#undef c"
  },
  {
    "path": "linkcuttree/path.cpp",
    "chars": 2923,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"base.cpp\"\n#undef "
  },
  {
    "path": "linkcuttree/subtree.cpp",
    "chars": 5430,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"base.cpp\"\n#undef "
  },
  {
    "path": "matching/bipartite.cpp",
    "chars": 1428,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(N M)\nstruct Bipartite{"
  },
  {
    "path": "matching/hopcroft_karp.cpp",
    "chars": 1450,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(E \\sqrt V)\nstruct Hopc"
  },
  {
    "path": "matching/tutte.cpp",
    "chars": 1045,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"../mod/mint.cpp\"\n"
  },
  {
    "path": "math/affine.cpp",
    "chars": 849,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\nnamespace Affine{\n  templat"
  },
  {
    "path": "math/bostanmori.cpp",
    "chars": 1048,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n// ref. https://qiita.com/ryuhe1/items/da5ac"
  },
  {
    "path": "math/carmichael.cpp",
    "chars": 486,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// min m s.t. a^m = 1 mod n"
  },
  {
    "path": "math/combination.cpp",
    "chars": 1572,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"extgcd.cpp\"\n#incl"
  },
  {
    "path": "math/convertbase.cpp",
    "chars": 490,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nvector<"
  },
  {
    "path": "math/dual.cpp",
    "chars": 370,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "math/enumerate_primes.cpp",
    "chars": 487,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// O(n)\nvector<int> enumera"
  },
  {
    "path": "math/extgcd.cpp",
    "chars": 545,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// find (x, y) s.t. ax + by"
  },
  {
    "path": "math/factorize.cpp",
    "chars": 375,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nmap<T, "
  },
  {
    "path": "math/fraction.cpp",
    "chars": 1163,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nstruct"
  },
  {
    "path": "math/isprime.cpp",
    "chars": 289,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename T>\nint isp"
  },
  {
    "path": "math/kitamasa.cpp",
    "chars": 1701,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\ntemplate<typename R>\nstruct "
  },
  {
    "path": "math/linearcongruence.cpp",
    "chars": 701,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n\n#define call_from_test\n#include \"extgcd.cpp\"\n#inclu"
  },
  {
    "path": "math/linearfunction.cpp",
    "chars": 762,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// a * x + b\ntemplate<typen"
  },
  {
    "path": "math/moebius.cpp",
    "chars": 540,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// [0, n]\nvector<int> moebi"
  },
  {
    "path": "math/quotients.cpp",
    "chars": 509,
    "preview": "#ifndef call_from_test\n#include <bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// split [1, n] into ranges"
  },
  {
    "path": "math/sum_of_floor.cpp",
    "chars": 524,
    "preview": "#ifndef call_from_test\n#include<bits/stdc++.h>\nusing namespace std;\n#endif\n//BEGIN CUT HERE\n// sum_{i=0}^{n-1} (ai + b) "
  }
]

// ... and 496 more files (download for full content)