SYMBOL INDEX (165 symbols across 23 files)

FILE: aho.cpp
  type Aho (line 3) | struct Aho {
    method Aho (line 7) | Aho(): to(1), cnt(1) {}
    method add (line 8) | int add(const string& s) {
    method init (line 21) | void init() {

FILE: bit.cpp
  type BIT (line 4) | struct BIT {
    method BIT (line 7) | BIT(int n=0):n(n),d(n+1) {}
    method add (line 8) | void add(int i, T x=1) {
    method T (line 13) | T sum(int i) {
    method T (line 20) | T sum(int l, int r) {

FILE: cart.cpp
  type CartesianTree (line 4) | struct CartesianTree {
    method CartesianTree (line 7) | CartesianTree() {}
    method CartesianTree (line 8) | CartesianTree(const vector<T>& a, bool _max=true) {

FILE: cc.cpp
  type CC (line 4) | struct CC {
    method CC (line 7) | CC(): initialized(false) {}
    method add (line 8) | void add(T x) { xs.push_back(x);}
    method init (line 9) | void init() {
    method T (line 18) | T operator[](int i) {
    method size (line 22) | int size() {

FILE: cht.cpp
  type CHT (line 3) | struct CHT {
    type Linear (line 4) | struct Linear {
      method Linear (line 6) | Linear(ll a=0, ll b=0): a(a), b(b) {}
      method ll (line 7) | ll operator()(ll x) const { return a*x+b;}
    method add (line 10) | void add(ll a, ll b) {
    method ll (line 21) | ll operator()(ll x) { // x: asc

FILE: comb.cpp
  type modinv (line 4) | struct modinv {
    method modinv (line 6) | modinv(): n(2), d({0,1}) {}
    method mint (line 7) | mint operator()(int i) {
    method mint (line 11) | mint operator[](int i) const { return d[i];}
  type modfact (line 13) | struct modfact {
    method modfact (line 15) | modfact(): n(2), d({1,1}) {}
    method mint (line 16) | mint operator()(int i) {
    method mint (line 20) | mint operator[](int i) const { return d[i];}
  type modfactinv (line 22) | struct modfactinv {
    method modfactinv (line 24) | modfactinv(): n(2), d({1,1}) {}
    method mint (line 25) | mint operator()(int i) {
    method mint (line 29) | mint operator[](int i) const { return d[i];}
  function mint (line 31) | mint comb(int n, int k) {

FILE: extgcd.cpp
  function ll (line 3) | ll extgcd(ll a, ll b, ll& i, ll& j) {

FILE: fps.cpp
  type fps (line 3) | struct fps : vm {
    method fps (line 6) | fps(Args...args): vm(args...) {}
    method fps (line 7) | fps(initializer_list<mint> a): vm(a.begin(),a.end()) {}
    method rsz (line 8) | void rsz(int n) { if (s < n) resize(n);}
    method fps (line 9) | fps& low_(int n) { resize(n); return d;}
    method fps (line 10) | fps low(int n) const { return fps(d).low_(n);}
    method mint (line 11) | mint& operator[](int i) { rsz(i+1); return vm::operator[](i);}
    method mint (line 12) | mint operator[](int i) const { return i<s ? vm::operator[](i) : 0;}
    method mint (line 13) | mint operator()(mint x) const {
    method fps (line 18) | fps operator-() const { fps r(d); rep(i,s) r[i] = -r[i]; return r;}
    method fps (line 19) | fps& operator+=(const fps& a) { rsz(a.size()); rep(i,a.size()) d[i] +=...
    method fps (line 20) | fps& operator-=(const fps& a) { rsz(a.size()); rep(i,a.size()) d[i] -=...
    method fps (line 21) | fps& operator*=(const fps& a) { return d = convolution(d, a);}
    method fps (line 22) | fps& operator*=(mint a) { rep(i,s) d[i] *= a; return d;}
    method fps (line 23) | fps& operator/=(mint a) { rep(i,s) d[i] /= a; return d;}
    method fps (line 24) | fps operator+(const fps& a) const { return fps(d) += a;}
    method fps (line 25) | fps operator-(const fps& a) const { return fps(d) -= a;}
    method fps (line 26) | fps operator*(const fps& a) const { return fps(d) *= a;}
    method fps (line 27) | fps operator*(mint a) const { return fps(d) *= a;}
    method fps (line 28) | fps operator/(mint a) const { return fps(d) /= a;}
    method fps (line 29) | fps operator~() const {
    method fps (line 34) | fps& operator/=(const fps& a) { int w = s; d *= ~a; return d.low_(w);}
    method fps (line 35) | fps operator/(const fps& a) const { return fps(d) /= a;}
    method fps (line 36) | fps integ() const {
  function ostream (line 44) | ostream& operator<<(ostream&o,const fps&a) {

FILE: gcd.cpp
  function ll (line 5) | ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
  function ll (line 6) | ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}

FILE: geom.cpp
  function equal (line 3) | bool equal(double a, double b) { return abs(a-b) < eps;}

FILE: geom/circle.cpp
  type Circle (line 4) | struct Circle {
    method Circle (line 6) | Circle(V o=V(), double r=0) : o(o), r(r) {}
    method crossPoint (line 7) | vector<V> crossPoint(const Circle& c) {
    method isInside (line 22) | bool isInside(const V& p) const {

FILE: geom/line.cpp
  type Line (line 1) | struct Line {
    method Line (line 3) | Line(V s=V(0,0), V t=V(0,0)):s(s),t(t){}
    method V (line 4) | V dir() const { return t-s;}
    method V (line 5) | V normalize() const { return dir().normalize();}
    method norm (line 6) | double norm() const { return dir().norm();}
    method ccw (line 12) | int ccw(const V& p) const {
    method touch (line 19) | bool touch(const Line& l) const {

FILE: geom/vector.cpp
  type V (line 3) | struct V {
    method V (line 5) | V(double x=0, double y=0): x(x), y(y) {}
    method V (line 6) | V& operator+=(const V& v) { x += v.x; y += v.y; return *this;}
    method V (line 7) | V operator+(const V& v) const { return V(*this) += v;}
    method V (line 8) | V& operator-=(const V& v) { x -= v.x; y -= v.y; return *this;}
    method V (line 9) | V operator-(const V& v) const { return V(*this) -= v;}
    method V (line 10) | V& operator*=(double s) { x *= s; y *= s; return *this;}
    method V (line 11) | V operator*(double s) const { return V(*this) *= s;}
    method V (line 12) | V& operator/=(double s) { x /= s; y /= s; return *this;}
    method V (line 13) | V operator/(double s) const { return V(*this) /= s;}
    method dot (line 14) | double dot(const V& v) const { return x*v.x + y*v.y;}
    method cross (line 15) | double cross(const V& v) const { return x*v.y - v.x*y;}
    method norm2 (line 16) | double norm2() const { return x*x + y*y;}
    method norm (line 17) | double norm() const { return sqrt(norm2());}
    method V (line 18) | V normalize() const { return *this/norm();}
    method V (line 19) | V rotate90() const { return V(y, -x);}
    method ort (line 20) | int ort() const { // orthant
  function istream (line 31) | istream& operator>>(istream& is, V& v) {
  function ostream (line 34) | ostream& operator<<(ostream& os, const V& v) {

FILE: lca.cpp
  type lca (line 4) | struct lca {
    method lca (line 11) | lca(int n):n(n),to(n),co(n),dep(n),costs(n) {
    method addEdge (line 16) | void addEdge(int a, int b, T c=0) {
    method dfs (line 20) | void dfs(int v, int d=0, T c=0, int p=-1) {
    method init (line 31) | void init(int _root=0) {
    method up (line 41) | int up(int v, int k) {
    method length (line 58) | int length(int a, int b) {
    method T (line 62) | T dist(int a, int b) {

FILE: mat.cpp
  type Matrix (line 3) | struct Matrix {
    method Matrix (line 6) | Matrix() {}
    method Matrix (line 7) | Matrix(int h, int w, T val=0): h(h), w(w), d(h, vector<T>(w,val)) {}
    method Matrix (line 8) | Matrix& unit() {
    method Matrix (line 15) | Matrix operator*(const Matrix& a) const {
    method Matrix (line 23) | Matrix pow(long long t) const {

FILE: mint.cpp
  type mint (line 7) | struct mint {
    method mint (line 9) | mint(ll x=0):x((x%mod+mod)%mod){}
    method mint (line 10) | mint operator-() const { return mint(-x);}
    method mint (line 11) | mint& operator+=(const mint a) {
    method mint (line 15) | mint& operator-=(const mint a) {
    method mint (line 19) | mint& operator*=(const mint a) { (x *= a.x) %= mod; return *this;}
    method mint (line 20) | mint operator+(const mint a) const { return mint(*this) += a;}
    method mint (line 21) | mint operator-(const mint a) const { return mint(*this) -= a;}
    method mint (line 22) | mint operator*(const mint a) const { return mint(*this) *= a;}
    method mint (line 23) | mint pow(ll t) const {
    method mint (line 32) | mint inv() const { return pow(mod-2);}
    method mint (line 33) | mint& operator/=(const mint a) { return *this *= a.inv();}
    method mint (line 34) | mint operator/(const mint a) const { return mint(*this) /= a;}
  function istream (line 36) | istream& operator>>(istream& is, mint& a) { return is >> a.x;}
  function ostream (line 37) | ostream& operator<<(ostream& os, const mint& a) { return os << a.x;}

FILE: mp.cpp
  type MP (line 4) | struct MP {
    method MP (line 8) | MP() {}
    method MP (line 9) | MP(const T& t): t(t) {
    method findAll (line 21) | vector<int> findAll(const T& s) {

FILE: perm.cpp
  type Perm (line 3) | struct Perm : vector<int> {
    method Perm (line 6) | Perm(int _n): vector<int>(_n) {
    method Perm (line 9) | Perm(Args...args): vector<int>(args...) {}
    method Perm (line 10) | Perm(initializer_list<int> a): vector<int>(a.begin(),a.end()) {}
    method Perm (line 11) | Perm operator+(const Perm& a) const {
    method Perm (line 16) | Perm& operator+=(const Perm& a) {
    method Perm (line 19) | Perm operator-() const {
    method Perm (line 24) | Perm operator-(const Perm& a) const {
    method Perm (line 27) | Perm& operator-=(const Perm& a) {

FILE: prime.cpp
  type Sieve (line 3) | struct Sieve {
    method Sieve (line 6) | Sieve(int n=1):n(n), f(n+1) {
    method isPrime (line 17) | bool isPrime(int x) { return f[x] == x;}
    method factorList (line 18) | vector<int> factorList(int x) {
    method factor (line 26) | vector<P> factor(int x) {
    method factor (line 39) | vector<pair<ll,int>> factor(ll x) {

FILE: rerooting.cpp
  type Rerooting (line 4) | struct Rerooting {
    type DP (line 5) | struct DP {
      method DP (line 6) | DP() {}
      method DP (line 7) | DP operator+(const DP& a) const {
      method DP (line 10) | DP addRoot() const {
    method Rerooting (line 19) | Rerooting(int n=0):n(n),to(n),dp(n),ans(n) {}
    method addEdge (line 20) | void addEdge(int a, int b) {
    method init (line 24) | void init() {
    method DP (line 29) | DP dfs(int v, int p=-1) {
      method DP (line 6) | DP() {}
      method DP (line 7) | DP operator+(const DP& a) const {
      method DP (line 10) | DP addRoot() const {
    method bfs (line 40) | void bfs(int v, const DP& dpP=DP(), int p=-1) {

FILE: template.cpp
  function main (line 9) | int main() {

FILE: uf.cpp
  type UnionFind (line 4) | struct UnionFind {
    method UnionFind (line 6) | UnionFind(int n=0): d(n,-1) {}
    method find (line 7) | int find(int x) {
    method unite (line 11) | bool unite(int x, int y) {
    method same (line 19) | bool same(int x, int y) { return find(x) == find(y);}
    method size (line 20) | int size(int x) { return -d[find(x)];}

FILE: z.cpp
  type Z (line 4) | struct Z {
    method Z (line 8) | Z() {}
    method Z (line 9) | Z(const string& s): s(s) { init();}
    method init (line 10) | void init() {