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(){