criyle/codenet-compile-errors huggingface dataset:
Language: C++

// http://judgef.u-aizu.ac.jp/onlinejudgef/description.jsp?id=GRL_3_A&lang=jp
// hos?????????????????????????????????
// lowflink????¨??????????????????§??????
#include <bits/stdc++.h>
using namespace std;
int ordf[100000], lowf[100000];
vector<int> edge[100000];
int judge[100000][100000];
int v, e, s, t, k;
void dfs(int u) {
    ordf[u] = k; k++;
    lowf[u] = ordf[u];
    for (int i=0; i<edge[u].size(); i++) {
        int a = edge[u][i];
        if (ordf[a] == -1) {
            judge[u][a] = 1; judge[a][u] = 1;
            dfs(a);
            lowf[u] = min(lowf[u], lowf[a]);
        } else if (judge[u][a] != 1) {
            lowf[u] = min(lowf[u], ordf[a]);
        }
    }
}
int main() {
    scanf("%d%d",&v,&e);
    for (int i=0; i<e; i++) {
        scanf("%d%d",&s,&t);
        edge[s].push_back(t); edge[t].push_back(s);
    }
    if (v == 1) {
    } else {
        k = 0;
        memset(ordf, -1, sizeof(ordf));
        dfs(0);
        // DFS??¨??¨??????????¬???°????????\???????????????
        int sum = 0;
        for (int j=0; j<edge[0].size(); j++) {
            if (judge[0][edge[0][j]] == 1) sum++;
        }
        if (sum > 1) puts("0");
        for (int i=1; i<v; i++) {
            bool flag = false;
            for (int j=0; j<edge[i].size(); j++) {
                if (ordf[i] <= lowf[edge[i][j]]) flag = true;
            }
            if (flag) printf("%d\n",i);
        }
    }
}

Compiler output:
/tmp/ccprH4DN.o: in function `dfs(int)':
a.cc:(.text+0xe): relocation truncated to fit: R_X86_64_PC32 against symbol `k' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x2c): relocation truncated to fit: R_X86_64_PC32 against symbol `k' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x35): relocation truncated to fit: R_X86_64_PC32 against symbol `k' defined in .bss section in /tmp/ccprH4DN.o
/tmp/ccprH4DN.o: in function `main':
a.cc:(.text+0x24b): relocation truncated to fit: R_X86_64_PC32 against symbol `e' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x255): relocation truncated to fit: R_X86_64_PC32 against symbol `v' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x27f): relocation truncated to fit: R_X86_64_PC32 against symbol `t' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x289): relocation truncated to fit: R_X86_64_PC32 against symbol `s' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x2a6): relocation truncated to fit: R_X86_64_PC32 against symbol `s' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x2c7): relocation truncated to fit: R_X86_64_PC32 against symbol `t' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x2d8): relocation truncated to fit: R_X86_64_PC32 against symbol `t' defined in .bss section in /tmp/ccprH4DN.o
a.cc:(.text+0x2f9): additional relocation overflows omitted from the output
collect2: error: ld returned 1 exit status
Language: C++

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

#define MAX_V 10000

int V, E;
vector<int> G[MAX_V];
bool visited[MAX_V];
int prenum[MAX_V];
int parent[MAX_V];
int lowest[MAX_V];
int timer, root;

void add_edge(int from, int to) {
  G[from].push_back(to);
  G[to].push_back(from);
}

void dfs(int u, int prev) {
    prenum[u] = timer;
    lowest[u] = timer;
    timer++;

    visited[u] = true;

    for(int i = 0; i < G[u].size(); i++) {
      int v = G[u][i];
      if(!visited[v]) {
        parent[v] = u;
        dfs(v, u);
        lowest[u] = min(lowest[u], lowest[v]);
      } else if(v != prev) {
        lowest[u] = min(lowest[u], prenum[v]);
      }
    }

}

int main () {
  cin >> V >> E;
  for(int i = 0; i < E; i++) {
    int v1, v2;
    cin >> v1 >> v2;
    add_edge(v1, v2);
  }

  for(int i = 0; i < V; i++) {
    visited[i] = false;
  }
  root = 0;
  timer = 1;
  dfs(root, -1);

  vector<int> ans;
  // (1)
  int num = 0;
  for(int i = 0; i < V; i++) {
    if(i == root) continue;
    if(parent[i] == root) num++;
  }
  if(num >= 2) ans.push_back(root);

  // (2)
  for(int i = 0; i < V; i++) {
    if(i == root || parent[i] == root) continue;
    else if(prenum[parent[i]] <= lowest[i])
      ans.push_back(parent[i]);
    // cout << i << endl;
  }

  sort(ans.begin(), ans.end());
  for(int i = 0; i < ans.size(); i++) {
    cout << ans[i] << endl;
  }

}

Compiler output:
a.cc: In function 'int main()':
a.cc:73:3: error: 'sort' was not declared in this scope; did you mean 'short'?
   73 |   sort(ans.begin(), ans.end());
      |   ^~~~
      |   short
Language: C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
vector<vector<int>> G(100000);
vector<bool> visit(100000, false);
vector<int> prenum(100000), parent(100000,-1), lowest(100000);
int time = 1;

void dfs(int u, int prev) {
	prenum[u] = lowest[u] = time; time++;
	visit[u] = true;
	for (int v : G[u]) {
		if (!visit[v]) {
			parent[v] = u;
			dfs(v, u);
			lowest[u] = min(lowest[u], lowest[v]);
		}
		else if (v != prev) {
			lowest[u] = min(lowest[u], prenum[v]);
		}
	}
}

int main() {
	cin.tie(0);ios::sync_with_stdio(false);
	int V, E; cin >> V >> E;
	vector<int> Count(V, 0), Ans;
	for (int i = 0; i < E;i++) {
		int s, t; cin >> s >> t;
		G[s].emplace_back(t);
		G[t].emplace_back(s);
	}
	dfs(0, -1);

	for (int u = 1; u < V;u++) {
		int p = parent[u];
		if (Count[p] != -1 && Count[p] == 1) { Ans.emplace_back(p); Count[p] = -1; }
		Count[p]++;

		if (p != 0 && prenum[p] <= lowest[u]) { Ans.emplace_back(p); Count[p] = -1; }
	}

	for (int i = 0; i < Ans.size();i++) {
		cout << Ans[i] << endl;
	}
}

Compiler output:
a.cc:8:5: error: 'int time' redeclared as different kind of entity
    8 | int time = 1;
      |     ^~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/time.h:76:15: note: previous declaration 'time_t time(time_t*)'
   76 | extern time_t time (time_t *__timer) __THROW;
      |               ^~~~
a.cc: In function 'void dfs(int, int)':
a.cc:11:33: error: invalid conversion from 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} to '__gnu_cxx::__alloc_traits<std::allocator<int>, int>::value_type' {aka 'int'} [-fpermissive]
   11 |         prenum[u] = lowest[u] = time; time++;
      |                                 ^~~~
      |                                 |
      |                                 time_t (*)(time_t*) noexcept {aka long int (*)(long int*) noexcept}
a.cc:11:39: warning: ISO C++ forbids incrementing a pointer of type 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} [-Wpointer-arith]
   11 |         prenum[u] = lowest[u] = time; time++;
      |                                       ^~~~
a.cc:11:43: error: lvalue required as increment operand
   11 |         prenum[u] = lowest[u] = time; time++;
      |                                           ^~
Language: C++

#include <iostream>
#include <vector>
#include <string>
#include <functional>
using namespace std;
const int INF = 1e9;
 
int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    vector<vector<int>> adj(n);
    for(int _ : in(m)) {
        int u, v;
        cin >> u >> v;
        adj[u].emplace_back(v);
        adj[v].emplace_back(u);
    }
    vector<int> depth(n, INF), ub(n, INF);
    vector<bool> isArt(n, false);
    function<void(int, int, int)> dfs = [&](int v, int p, int d) {
        depth[v] = d;
        ub[v] = d;
        int k = 0;
        for(int nv : adj[v]) {
            if(nv == p) continue;
            if(depth[nv] == INF) {
                ++k;
                dfs(nv, v, d + 1);
                ub[v] = min(ub[v], ub[nv]);
                if(d && ub[nv] >= depth[v]) isArt[v] = true; // ???????????????
            }
            else {
                ub[v] = min(ub[v], depth[nv]);
            }
        }
        if(!d && k > 1) isArt[v] = true;
    };
    dfs(0, -1, 0);
    for(int i : in(n)) if(isArt[i]) cout << i << '\n';
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:14:17: error: 'in' was not declared in this scope; did you mean 'n'?
   14 |     for(int _ : in(m)) {
      |                 ^~
      |                 n
a.cc:41:17: error: 'in' was not declared in this scope; did you mean 'i'?
   41 |     for(int i : in(n)) if(isArt[i]) cout << i << '\n';
      |                 ^~
      |                 i
Language: C++

#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <set>
#include <utility>
#include <vector>

using namespace std;

const int MAX = 100000;
vector<int> E[MAX];

bool visited[MAX];

int time = 1;

int parent[MAX];
int prenum[MAX];
int lowest[MAX];
int NIL = 100001;

void dfs(int current, int prev) {

	visited[current] = true;
	prenum[current] = lowest[current] = time++;
	for (int i = 0; i < (int) E[current].size(); ++i) {

		int next = E[current][i];

//		cout << "current???" << current << ":next???" << next << endl;

		if (visited[next] == false) {
			parent[next] = current;
			dfs(next, current);
			lowest[current] = min(lowest[current], lowest[next]);
		} else if (next != prev) {
			lowest[current] = min(prenum[current], lowest[next]);
		}
//		cout << "current???" << current << ":lowest[current]???" << lowest[current] << endl;
	}
}

int main() {

	int v, e;
	scanf("%d %d", &v, &e);

	for (int i = 0; i < v; ++i) {
		visited[i] = false;
		parent[i] = prenum[i] = lowest[i] = NIL;
	}

	for (int i = 0; i < e; ++i) {
		int s, t;
		scanf("%d %d", &s, &t);

		E[s].push_back(t);
		E[t].push_back(s);
	}

	dfs(0, -1);

	set<int> ans;

	int np = 0;
	for (int i = 1; i < v; ++i) {
		int p = parent[i];
		if (p == 0) {
			np++;
		} else if (prenum[p] <= lowest[i]) {
			ans.insert(parent[i]);
		}
	}

	if (np > 1)
		ans.insert(0);

	for (set<int>::iterator it = ans.begin(); it != ans.end(); it++) {
		cout << *it << endl;
	}

	return 0;
}

Compiler output:
a.cc:16:5: error: 'int time' redeclared as different kind of entity
   16 | int time = 1;
      |     ^~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:3:
/usr/include/time.h:76:15: note: previous declaration 'time_t time(time_t*)'
   76 | extern time_t time (time_t *__timer) __THROW;
      |               ^~~~
a.cc: In function 'void dfs(int, int)':
a.cc:26:45: warning: ISO C++ forbids incrementing a pointer of type 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} [-Wpointer-arith]
   26 |         prenum[current] = lowest[current] = time++;
      |                                             ^~~~
a.cc:26:49: error: lvalue required as increment operand
   26 |         prenum[current] = lowest[current] = time++;
      |                                                 ^~
Language: C++

#include <iostream>
#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
const int num = 100000;
vector<int> m[num];
int n, c[num], pn[num], lo[num], p[num];
int time = 0;
inline void art(int cu, int pre) {
	pn[cu] = lo[cu] = time++;
	c[cu] = 1;
	for (int i = 0; i < m[cu].size(); i++) {
		int v = m[cu][i];
		if (!c[v]) {
			p[v] = cu;
			art(v, cu);
			lo[cu] = min(lo[cu], lo[v]);
		}
		else if (v != pre) lo[cu] = min(pn[v], lo[cu]);
	}
}
int main() {
	int e, s, t;
	cin >> n >> e;
	for (int i = 0; i < e; i++) {
		scanf("%d%d", &s, &t);
		m[s].push_back(t);
		m[t].push_back(s);
	}
	for (int i = 0; i < n; i++) c[i] = 0;
	art(0, -1);
	set<int> ans;
	int cn = 0;
	for (int i = 1; i < n; i++) {
		int v = p[i];
		if (v == 0) cn++;
		else if (pn[v] <= lo[i]) ans.insert(v);
	}
	if (cn >= 2) ans.insert(0);
	for (set<int>::iterator it = ans.begin(); it != ans.end(); it++)
		cout << *it << endl;
	return 0;
}

Compiler output:
a.cc:10:5: error: 'int time' redeclared as different kind of entity
   10 | int time = 0;
      |     ^~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/time.h:76:15: note: previous declaration 'time_t time(time_t*)'
   76 | extern time_t time (time_t *__timer) __THROW;
      |               ^~~~
a.cc: In function 'void art(int, int)':
a.cc:12:27: warning: ISO C++ forbids incrementing a pointer of type 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} [-Wpointer-arith]
   12 |         pn[cu] = lo[cu] = time++;
      |                           ^~~~
a.cc:12:31: error: lvalue required as increment operand
   12 |         pn[cu] = lo[cu] = time++;
      |                               ^~
Language: C++

#include <iostream>
#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
const int num = 100000;
vector<int> m[num];
int n, c[num], pn[num], lo[num], p[num];
int time = 0;
inline void art(int cu, int pre) {
	pn[cu] = lo[cu] = time;
	time++
	c[cu] = 1;
	for (int i = 0; i < m[cu].size(); i++) {
		int v = m[cu][i];
		if (!c[v]) {
			p[v] = cu;
			art(v, cu);
			lo[cu] = min(lo[cu], lo[v]);
		}
		else if (v != pre) lo[cu] = min(pn[v], lo[cu]);
	}
}
int main() {
	int e, s, t;
	cin >> n >> e;
	for (int i = 0; i < e; i++) {
		scanf("%d%d", &s, &t);
		m[s].push_back(t);
		m[t].push_back(s);
	}
	for (int i = 0; i < n; i++) c[i] = 0;
	art(0, -1);
	set<int> ans;
	int cn = 0;
	for (int i = 1; i < n; i++) {
		int v = p[i];
		if (v == 0) cn++;
		else if (pn[v] <= lo[i]) ans.insert(v);
	}
	if (cn >= 2) ans.insert(0);
	for (set<int>::iterator it = ans.begin(); it != ans.end(); it++)
		cout << *it << endl;
	return 0;
}

Compiler output:
a.cc:10:5: error: 'int time' redeclared as different kind of entity
   10 | int time = 0;
      |     ^~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/time.h:76:15: note: previous declaration 'time_t time(time_t*)'
   76 | extern time_t time (time_t *__timer) __THROW;
      |               ^~~~
a.cc: In function 'void art(int, int)':
a.cc:12:27: error: invalid conversion from 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} to 'int' [-fpermissive]
   12 |         pn[cu] = lo[cu] = time;
      |                           ^~~~
      |                           |
      |                           time_t (*)(time_t*) noexcept {aka long int (*)(long int*) noexcept}
a.cc:13:9: warning: ISO C++ forbids incrementing a pointer of type 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} [-Wpointer-arith]
   13 |         time++
      |         ^~~~
a.cc:13:13: error: lvalue required as increment operand
   13 |         time++
      |             ^~
Language: C++

#include <iostream>
#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
const int num = 100000;
vector<int> m[num];
int n, c[num], pn[num], lo[num], p[num];
int time = 0;
inline void art(int cu, int pre) {
	pn[cu] = lo[cu] = time;
	time++;
	c[cu] = 1;
	for (int i = 0; i < m[cu].size(); i++) {
		int v = m[cu][i];
		if (!c[v]) {
			p[v] = cu;
			art(v, cu);
			lo[cu] = min(lo[cu], lo[v]);
		}
		else if (v != pre) lo[cu] = min(pn[v], lo[cu]);
	}
}
int main() {
	int e, s, t;
	cin >> n >> e;
	for (int i = 0; i < e; i++) {
		scanf("%d%d", &s, &t);
		m[s].push_back(t);
		m[t].push_back(s);
	}
	for (int i = 0; i < n; i++) c[i] = 0;
	art(0, -1);
	set<int> ans;
	int cn = 0;
	for (int i = 1; i < n; i++) {
		int v = p[i];
		if (v == 0) cn++;
		else if (pn[v] <= lo[i]) ans.insert(v);
	}
	if (cn >= 2) ans.insert(0);
	for (set<int>::iterator it = ans.begin(); it != ans.end(); it++)
		cout << *it << endl;
	return 0;
}

Compiler output:
a.cc:10:5: error: 'int time' redeclared as different kind of entity
   10 | int time = 0;
      |     ^~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/time.h:76:15: note: previous declaration 'time_t time(time_t*)'
   76 | extern time_t time (time_t *__timer) __THROW;
      |               ^~~~
a.cc: In function 'void art(int, int)':
a.cc:12:27: error: invalid conversion from 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} to 'int' [-fpermissive]
   12 |         pn[cu] = lo[cu] = time;
      |                           ^~~~
      |                           |
      |                           time_t (*)(time_t*) noexcept {aka long int (*)(long int*) noexcept}
a.cc:13:9: warning: ISO C++ forbids incrementing a pointer of type 'time_t (*)(time_t*) noexcept' {aka 'long int (*)(long int*) noexcept'} [-Wpointer-arith]
   13 |         time++;
      |         ^~~~
a.cc:13:13: error: lvalue required as increment operand
   13 |         time++;
      |             ^~
Language: C++

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;

#include<map>
#include<set>
#include<queue>

typedef long long ll;
typedef unsigned long long ull;

const int MAX_N = 1000000;
static const int INFTY = (1 << 21);

class Edge{
public:
	int from, to, cost;
	int backedge;
	Edge(int from = 0, int to = 0, int cost = 0) :
		from(from), to(to), cost(cost){
		backedge = -1;
	}

};

class Node{
public:
	vector<Edge> edges;
	int prenum;
	int parent;
	int lowest;
	Node(){
		prenum = -1;
		parent = -1;
	}
};

class Graph{
public:
	vector<Node> nodes;
	int prenum;
	Graph(int n) {
		rep(i, n) { Node n;  nodes.push_back(n); }
		prenum = 0;
	}
};

Graph G(0);

void dfs(Edge &e){

	Node *n = &(G.nodes[e.to]);

	if (n->prenum != -1) {
		int parent = G.nodes[e.from].parent;
		if (e.to == parent){
			e.backedge = -1; // neither backedge nor treeedge
		}
		else{
			e.backedge = 1;
		}
		return;
	}

	// set parameter
	G.prenum++;
	e.backedge = 0; // not backage
	n->prenum = G.prenum;
	n->parent = e.from;
	n->lowest = n->prenum;

	for (auto &ee : n->edges){
		dfs(ee);
	}

	for (auto &ee : n->edges){
		if (ee.backedge != -1){
			n->lowest = min(n->lowest, G.nodes[ee.to].lowest);
		}
	}

}


int main() {

	int V, E;
	cin >> V >> E;

	G = Graph(V);

	rep(i, E){
		int from, to;
		cin >> from >> to;
		G.nodes[from].edges.push_back(Edge(from, to, 0));
		G.nodes[to].edges.push_back(Edge(to, from, 0));
	}

	dfs(Edge(-1, 0, 0));

	rep(i, V){
		// printf("%d %d %d %d\n", i, G.nodes[i].parent, G.nodes[i].prenum, G.nodes[i].lowest);
	}

	set<int> ret;
	rep(i, V){
		if (G.nodes[i].parent == -1){
			int count = 0;
			rep(j, V){
				if (G.nodes[j].parent == i) count++;
			}
			if (count > 1) ret.insert(i);
		}
		else{
			Node n = G.nodes[i];
			Node p = G.nodes[n.parent];
			if (p.prenum <= n.lowest && p.parent != -1){
				ret.insert(n.parent);
			}
		}
	}

	for (auto &i : ret){
		cout << i << endl;
	}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:110:13: error: cannot bind non-const lvalue reference of type 'Edge&' to an rvalue of type 'Edge'
  110 |         dfs(Edge(-1, 0, 0));
      |             ^~~~~~~~~~~~~~
a.cc:61:16: note:   initializing argument 1 of 'void dfs(Edge&)'
   61 | void dfs(Edge &e){
      |          ~~~~~~^
Language: C++

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;

#include<map>
#include<set>
#include<queue>

typedef long long ll;
typedef unsigned long long ull;

const int MAX_N = 1000000;
static const int INFTY = (1 << 21);

class Edge{
public:
	int from, to, cost;
	int backedge;
	Edge(int from = 0, int to = 0, int cost = 0) :
		from(from), to(to), cost(cost){
		backedge = -1;
	}

};

class Node{
public:
	vector<Edge> edges;
	int prenum;
	int parent;
	int lowest;
	Node(){
		prenum = -1;
		parent = -1;
	}
};

class Graph{
public:
	vector<Node> nodes;
	int prenum;
	Graph(int n) {
		rep(i, n) { Node n;  nodes.push_back(n); }
		prenum = 0;
	}
};

Graph *G = nullptr;

void dfs(Edge &e){

	Node *n = &(G->nodes[e.to]);

	if (n->prenum != -1) {
		int parent = G->nodes[e.from].parent;
		if (e.to == parent){
			e.backedge = -1; // neither backedge nor treeedge
		}
		else{
			e.backedge = 1;
		}
		return;
	}

	// set parameter
	G->prenum++;
	e.backedge = 0; // not backage
	n->prenum = G->prenum;
	n->parent = e.from;
	n->lowest = n->prenum;

	for (auto &ee : n->edges){
		dfs(ee);
	}

	for (auto &ee : n->edges){
		if (ee.backedge != -1){
			n->lowest = min(n->lowest, G->nodes[ee.to].lowest);
		}
	}

}


int main() {

	int V, E;
	cin >> V >> E;

	G = & Graph(V);

	rep(i, E){
		int from, to;
		cin >> from >> to;
		G->nodes[from].edges.push_back(Edge(from, to, 0));
		G->nodes[to].edges.push_back(Edge(to, from, 0));
	}

	Edge e(-1, 0, 0);
	dfs(e);

	rep(i, V){
		// printf("%d %d %d %d\n", i, G.nodes[i].parent, G.nodes[i].prenum, G.nodes[i].lowest);
	}

	set<int> ret;
	rep(i, V){
		if (G->nodes[i].parent == -1){
			int count = 0;
			rep(j, V){
				if (G->nodes[j].parent == i) count++;
			}
			if (count > 1) ret.insert(i);
		}
		else{
			Node n = G->nodes[i];
			Node p = G->nodes[n.parent];
			if (p.prenum <= n.lowest && p.parent != -1){
				ret.insert(n.parent);
			}
		}
	}

	for (auto &i : ret){
		cout << i << endl;
	}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:101:15: error: taking address of rvalue [-fpermissive]
  101 |         G = & Graph(V);
      |               ^~~~~~~~
Language: C++

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;

#include<map>
#include<set>
#include<queue>

typedef long long ll;
typedef unsigned long long ull;

const int MAX_N = 1000000;
static const int INFTY = (1 << 21);

class Edge{
public:
	int from, to, cost;
	int backedge;
	Edge(int from = 0, int to = 0, int cost = 0) :
		from(from), to(to), cost(cost){
	}

};

class Node{
public:
	vector<Edge> edges;
	int prenum;
	int parent;
	int lowest;
	Node(){
		prenum = -1;
		parent = -1;
	}
};

class Graph{
public:
	vector<Node> nodes;
	int prenum;

	Graph(int n) {
		rep(i, n) { Node n;  nodes.push_back(n); }
		prenum = 0;
	}

	Node operator [] (int i) const{
		return nodes[i];
	}

};

Graph G(0);

void dfs(Edge &e){

	Node& n = G[e.to];

	if (n.prenum != -1) {
		int parent = G[e.from].parent;
		if (e.to == parent){
			e.backedge = -1; // edge to its parent
		}
		else{
			e.backedge = 1; // backedge
		}
		return;
	}

	// set parameter
	G.prenum++;
	e.backedge = 0; // edge-of-DFStree
	n.prenum = G.prenum;
	n.parent = e.from;
	n.lowest = n.prenum;

	for (Edge &eg : n.edges){
		dfs(eg);
	}

	for (Edge &eg : n.edges){
		// edge-of-DFStree
		if (eg.backedge == 0){
			n.lowest = min(n.lowest, G[eg.to].lowest);
		}
		// backedge
		if (eg.backedge == 1){
			n.lowest = min(n.lowest, G[eg.to].prenum);
		}
	}

}


int main() {

	int V, E;
	cin >> V >> E;

	G = Graph(V);

	rep(i, E){
		int from, to;
		cin >> from >> to;
		G[from].edges.push_back(Edge(from, to, 0));
		G[to].edges.push_back(Edge(to, from, 0));
	}

	Edge e0(-1, 0, 0);
	dfs(e0);

	rep(i, V){
		// printf("%d %d %d %d\n", i, G[i].parent, G[i].prenum, G[i].lowest);
	}

	set<int> ret;

	// root
	rep(i, V){
		if (G[i].parent == -1){
			int count = 0;
			rep(j, V){
				if (G[j].parent == i) count++;
			}
			if (count > 1) ret.insert(i);
		}
	}

	// not root
	rep(i, V){
		if(G[i].parent != -1){
			Node& n = G[i];
			Node& p = G[n.parent];
			if (p.prenum <= n.lowest && p.parent != -1){
				ret.insert(n.parent);
			}
		}
	}

	for (int i : ret){
		cout << i << endl;
	}
}

Compiler output:
a.cc: In function 'void dfs(Edge&)':
a.cc:68:25: error: cannot bind non-const lvalue reference of type 'Node&' to an rvalue of type 'Node'
   68 |         Node& n = G[e.to];
      |                   ~~~~~~^
a.cc: In function 'int main()':
a.cc:143:38: error: cannot bind non-const lvalue reference of type 'Node&' to an rvalue of type 'Node'
  143 |                         Node& n = G[i];
      |                                   ~~~^
a.cc:144:45: error: cannot bind non-const lvalue reference of type 'Node&' to an rvalue of type 'Node'
  144 |                         Node& p = G[n.parent];
      |                                   ~~~~~~~~~~^
Language: C++

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;

#include<map>
#include<set>
#include<queue>

typedef long long ll;
typedef unsigned long long ull;

const int MAX_N = 1000000;
static const int INFTY = (1 << 21);

class Edge{
public:
	int from, to, cost;
	int backedge;
	Edge(int from = 0, int to = 0, int cost = 0) :
		from(from), to(to), cost(cost){
		backedge = -1;
	}

};

class Node{
public:
	vector<Edge> edges;
	int prenum;
	int parent;
	int lowest;
	Node(){
		prenum = -1;
		parent = -1;
	}
};

class Graph{
public:
	vector<Node> nodes;
	int prenum;

	Graph(int n) {
		rep(i, n) { Node n;  nodes.push_back(n); }
		prenum = 0;
	}

	Node operator [] (int i) const{
		return nodes[i];
	}

};

Graph G(0);

void dfs(Edge &e){

	Node& n = G[e.to];

	if (n.prenum != -1) {
		int parent = G[e.from].parent;
		if (e.to == parent){
			e.backedge = -1; // edge to its parent
		}
		else{
			e.backedge = 1; // backedge
		}
		return;
	}

	// set parameter
	G.prenum++;
	e.backedge = 0; // edge-of-DFStree
	n.prenum = G.prenum;
	n.parent = e.from;
	n.lowest = n.prenum;

	for (Edge &eg : n.edges){
		dfs(eg);
	}

	for (Edge &eg : n.edges){
		// edge-of-DFStree
		if (eg.backedge == 0){
			n.lowest = min(n.lowest, G[eg.to].lowest);
		}
		// backedge
		if (eg.backedge == 1){
			n.lowest = min(n.lowest, G[eg.to].prenum);
		}
	}

}


int main() {

	int V, E;
	cin >> V >> E;

	G = Graph(V);

	rep(i, E){
		int from, to;
		cin >> from >> to;
		G[from].edges.push_back(Edge(from, to, 0));
		G[to].edges.push_back(Edge(to, from, 0));
	}

	Edge e0(-1, 0, 0);
	dfs(e0);

	rep(i, V){
		// printf("%d %d %d %d\n", i, G[i].parent, G[i].prenum, G[i].lowest);
	}

	set<int> ret;

	// root
	rep(i, V){
		if (G[i].parent == -1){
			int count = 0;
			rep(j, V){
				if (G[j].parent == i) count++;
			}
			if (count > 1) ret.insert(i);
		}
	}

	// not root
	rep(i, V){
		if(G[i].parent != -1){
			Node& n = G[i];
			Node& p = G[n.parent];
			if (p.prenum <= n.lowest && p.parent != -1){
				ret.insert(n.parent);
			}
		}
	}

	for (int i : ret){
		cout << i << endl;
	}
}

Compiler output:
a.cc: In function 'void dfs(Edge&)':
a.cc:69:25: error: cannot bind non-const lvalue reference of type 'Node&' to an rvalue of type 'Node'
   69 |         Node& n = G[e.to];
      |                   ~~~~~~^
a.cc: In function 'int main()':
a.cc:144:38: error: cannot bind non-const lvalue reference of type 'Node&' to an rvalue of type 'Node'
  144 |                         Node& n = G[i];
      |                                   ~~~^
a.cc:145:45: error: cannot bind non-const lvalue reference of type 'Node&' to an rvalue of type 'Node'
  145 |                         Node& p = G[n.parent];
      |                                   ~~~~~~~~~~^
Language: C++

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef vector<vector<int> > Graph;
struct Node{
  int order, min_order;
};
class ArticulationFind{
public:
  ArticulationFind(Graph _g){
    g = _g;
    node.resize(g.size(), Node{-1, (int)1e9});
  }
  vector<int> find(){
    if(current_order == 0)dfs();
    return articulation;
  }
private:
  void dfs(int current  = 0,
           int previous = -1){
    int to, min_v = current, cnt = 0;
    node[current].order     = current_order;
    node[current].min_order = current_order++;
    for (int i = 0; i < g[current].size(); i++) {
      bool used = false;
      to = g[current][i];
      if(node[to].order == -1){
        used = true;
        dfs(to, current);
        cnt++;
      }
      if(previous == to)continue;
      node[current].min_order = 
        min(node[current].min_order,
            node[to].min_order);
      if(used){
        min_v = min(min_v, node[to].min_order);
      }
    }
    if(min_v == node[current].order and
       previous != -1 and g[current].size() > 1){
      articulation.emplace_back(current);
    }
    if(cnt == 1 and current = 0)articulation.emplace_back(current);
  }
  int current_order = 0;
  vector<int> articulation;
  Graph g;
  vector<Node> node;
};

int main(int argc, char *argv[]){
  int n, m;
  std::cin >> n >> m;
  Graph g(n, vector<int>());
  for (int i = 0; i < m; i++) {
    int to, from;
    std::cin >> to >> from;
    g[to].push_back(from);
    g[from].push_back(to);
  }
  ArticulationFind bf(g);
  vector<int> articulation = bf.find();
  sort(articulation.begin(), articulation.end());
  for (int i = 0; i < articulation.size(); i++) {
    std::cout << articulation[i] << std::endl;
  }
  return 0;
}

Compiler output:
a.cc: In member function 'void ArticulationFind::dfs(int, int)':
a.cc:46:17: error: lvalue required as left operand of assignment
   46 |     if(cnt == 1 and current = 0)articulation.emplace_back(current);
      |        ~~~~~~~~~^~~~~~~~~~~
Language: C++

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

typedef vector<vector<int> > Graph;
struct Node{
  int order, min_order;
};
class ArticulationFind{
public:
  ArticulationFind(Graph _g){
    g = _g;
    node.resize(g.size(), Node{-1, (int)1e9});
  }
  vector<int> find(){
    if(current_order == 0)dfs();
    return articulation;
  }
private:
  void dfs(int v  = 0,
           int previous = -1){
    int to, min_v = v, cnt = 0;
    node[v].order     = v_order;
    node[v].min_order = v_order++;
    bool isAP = false;
    for (int i = 0; i < g[v].size(); i++) {
      to = g[v][i];
      if(previous == to)continue;
      if(node[to].order == -1){
        dfs(to, v);
        cnt++;
      }
      node[v].min_order = 
        min(node[v].min_order,
            node[to].min_order);
      isAP |= (min_v <= node[to].min_order);
          
      min_v = min(min_v, node[to].min_order);
    }
    if(min_v == node[v].order and
       previous != -1 and g[v].size() > 1){
      articulation.emplace_back(v);
    }
    if(cnt > 1 and v == 0)articulation.emplace_back(v);
  }
  int v_order = 0;
  vector<int> articulation;
  Graph g;
  vector<Node> node;
};

int main(int argc, char *argv[]){
  int n, m;
  std::cin >> n >> m;
  Graph g(n, vector<int>());
  for (int i = 0; i < m; i++) {
    int to, from;
    std::cin >> to >> from;
    g[to].push_back(from);
    g[from].push_back(to);
  }
  ArticulationFind bf(g);
  vector<int> articulation = bf.find();
  sort(articulation.begin(), articulation.end());
  for (int i = 0; i < articulation.size(); i++) {
    std::cout << articulation[i] << std::endl;
  }
  return 0;
}

Compiler output:
a.cc: In member function 'std::vector<int> ArticulationFind::find()':
a.cc:17:8: error: 'current_order' was not declared in this scope
   17 |     if(current_order == 0)dfs();
      |        ^~~~~~~~~~~~~
Language: C++

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
vector<int> neighbors[100000];
//int status[100000];
int dtime[100000];
int hca[100000];
bool visited[100000];
int clock;
int parent[100000];

void dfs(int current,int prev)
{
    visited[current]=true;
    hca[current]=dtime[current]=clock++;
    for(int i=0;i<neighbors[current].size();i++)
    {
        int next=neighbors[current][i];

        if(!visited[next])
        {
            parent[next]=current;  
            dfs(next,current); 
            if(hca[next]<dtime[current]) 
            {
                hca[current]=min(hca[next],hca[current]);  
            }
        }
        else if(next!=prev)  
        {
            hca[current]=min(hca[current],dtime[next]);  
        }
    }
}

void bcc(int n)
{
    for(int i=0;i<n;i++) visited[i]=false;
    clock=1;

    dfs(0,-1); 
    int np;
    set<int> result;  
    for(int i=1;i<n;i++)
    {
        int p=parent[i];
        if(p==0) np++;
        else if(hca[i]>=dtime[p]) result.insert(p);
    }
    if(np>=2) result.insert(0);  
    for(set<int>::iterator it=result.begin();it!=result.end();it++)
    {
        cout<<*it<<endl;
    }
}
int main()
{
    int num,N;
    cin>>N>>num;
    for(int i=0;i<num;i++)
    {
        int a,b;
        cin>>a>>b;
        neighbors[a].push_back(b);
        neighbors[b].push_back(a);
    }
    bcc(N);
    return 0;
}

Compiler output:
a.cc:11:5: error: 'int clock' redeclared as different kind of entity
   11 | int clock;
      |     ^~~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/time.h:72:16: note: previous declaration 'clock_t clock()'
   72 | extern clock_t clock (void) __THROW;
      |                ^~~~~
a.cc: In function 'void dfs(int, int)':
a.cc:17:33: warning: ISO C++ forbids incrementing a pointer of type 'clock_t (*)() noexcept' {aka 'long int (*)() noexcept'} [-Wpointer-arith]
   17 |     hca[current]=dtime[current]=clock++;
      |                                 ^~~~~
a.cc:17:38: error: lvalue required as increment operand
   17 |     hca[current]=dtime[current]=clock++;
      |                                      ^~
a.cc: In function 'void bcc(int)':
a.cc:41:10: error: assignment of function 'clock_t clock()'
   41 |     clock=1;
      |     ~~~~~^~
Language: C++

#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
vector<int> neighbors[100000];
//int status[100000];
int dtime[100000];
int hca[100000];
bool visited[100000];
int clock=0;
int parent[100000];

void dfs(int current,int prev)
{
    visited[current]=true;
    hca[current]=dtime[current]=clock++;
    for(int i=0;i<neighbors[current].size();i++)
    {
        int next=neighbors[current][i];

        if(!visited[next])
        {
            parent[next]=current;  
            dfs(next,current); 
            if(hca[next]<dtime[current]) 
            {
                hca[current]=min(hca[next],hca[current]);  
            }
        }
        else if(next!=prev)  
        {
            hca[current]=min(hca[current],dtime[next]);  
        }
    }
}

void bcc(int n)
{
    for(int i=0;i<n;i++) visited[i]=false;
    clock=1;

    dfs(0,-1); 
    int np;
    set<int> result;  
    for(int i=1;i<n;i++)
    {
        int p=parent[i];
        if(p==0) np++;
        else if(hca[i]>=dtime[p]) result.insert(p);
    }
    if(np>=2) result.insert(0);  
    for(set<int>::iterator it=result.begin();it!=result.end();it++)
    {
        cout<<*it<<endl;
    }
}
int main()
{
    int num,N;
    cin>>N>>num;
    for(int i=0;i<num;i++)
    {
        int a,b;
        cin>>a>>b;
        neighbors[a].push_back(b);
        neighbors[b].push_back(a);
    }
    bcc(N);
    return 0;
}

Compiler output:
a.cc:11:5: error: 'int clock' redeclared as different kind of entity
   11 | int clock=0;
      |     ^~~~~
In file included from /usr/include/pthread.h:23,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h:35,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h:157,
                 from /usr/include/c++/14/ext/atomicity.h:35,
                 from /usr/include/c++/14/bits/ios_base.h:39,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/time.h:72:16: note: previous declaration 'clock_t clock()'
   72 | extern clock_t clock (void) __THROW;
      |                ^~~~~
a.cc: In function 'void dfs(int, int)':
a.cc:17:33: warning: ISO C++ forbids incrementing a pointer of type 'clock_t (*)() noexcept' {aka 'long int (*)() noexcept'} [-Wpointer-arith]
   17 |     hca[current]=dtime[current]=clock++;
      |                                 ^~~~~
a.cc:17:38: error: lvalue required as increment operand
   17 |     hca[current]=dtime[current]=clock++;
      |                                      ^~
a.cc: In function 'void bcc(int)':
a.cc:41:10: error: assignment of function 'clock_t clock()'
   41 |     clock=1;
      |     ~~~~~^~
Language: C++

#include<iostream>
#include<vector>
#include<set>
using namespace std;

#define MAX 100000

vector <int> G[MAX];
int N;
bool visited[MAX];
int prenum[MAX],parent[MAX],lowest[MAX],timer;

void dfs(int current,int prev)
{
	prenum[current]=lowest[current]=timer;
	timer++;
	
	visited[current]=true;
	
	int next;
	
	for(int i-0;i<G[current].size();i++;)
	{
		next=G[current][i];
		if(!visited[next])
		{
			parent[next]=current;
			dfs(next,current);
			
			lowest[current]=min(lowest[currnt],lowest[next]);
		}
		else if(next!=prev)
		{
			lowest[current]=min(lowest[current],prenum[next]);
		}
	}
}

void art_points()
{
	for(int i=0;i<N;i++)visited[i]=false;
	timer=1;
	dfs(0,-1);
	set<int> ap;
	int np=0;
	for(int i=1;i<N;i++)
	{
		int p=parent[i];
		if(p==0)np++;
		else if(prenum[p]<=lowest[i])ap.insert(p);
	}
	if(np>1)ap.insert(0);
	for(set<int>::iterator it=ap.begin();it!=ap.end();it++)cout<<*it<<endl;
}

int main()
{
	int m;
	cin>>N>>m;
	
	for(int i=0;i<m;i++)
	{
		int s,t;
		cin>>s>>t;
		G[s].push_back(t);
		G[t].push_back(s);
	}
	art_points();
	
	return 0;
}

Compiler output:
a.cc: In function 'void dfs(int, int)':
a.cc:22:18: error: expected ';' before '-' token
   22 |         for(int i-0;i<G[current].size();i++;)
      |                  ^
      |                  ;
a.cc:22:40: error: expected ')' before ';' token
   22 |         for(int i-0;i<G[current].size();i++;)
      |            ~                           ^
      |                                        )
a.cc:22:41: error: 'i' was not declared in this scope
   22 |         for(int i-0;i<G[current].size();i++;)
      |                                         ^
a.cc:22:45: error: expected primary-expression before ')' token
   22 |         for(int i-0;i<G[current].size();i++;)
      |                                             ^
Language: C++

#include<iostream>
#include<vector>
#include<set>
using namespace std;

#define MAX 100000

vector <int> G[MAX];
int N;
bool visited[MAX];
int prenum[MAX],parent[MAX],lowest[MAX],timer;

void dfs(int current,int prev)
{
	prenum[current]=lowest[current]=timer;
	timer++;
	
	visited[current]=true;
	
	int next;
	
	for(int i=0;i<G[current].size();i++;)
	{
		next=G[current][i];
		if(!visited[next])
		{
			parent[next]=current;
			dfs(next,current);
			
			lowest[current]=min(lowest[currnt],lowest[next]);
		}
		else if(next!=prev)
		{
			lowest[current]=min(lowest[current],prenum[next]);
		}
	}
}

void art_points()
{
	for(int i=0;i<N;i++)visited[i]=false;
	timer=1;
	dfs(0,-1);
	set<int> ap;
	int np=0;
	for(int i=1;i<N;i++)
	{
		int p=parent[i];
		if(p==0)np++;
		else if(prenum[p]<=lowest[i])ap.insert(p);
	}
	if(np>1)ap.insert(0);
	for(set<int>::iterator it=ap.begin();it!=ap.end();it++)cout<<*it<<endl;
}

int main()
{
	int m;
	cin>>N>>m;
	
	for(int i=0;i<m;i++)
	{
		int s,t;
		cin>>s>>t;
		G[s].push_back(t);
		G[t].push_back(s);
	}
	art_points();
	
	return 0;
}

Compiler output:
a.cc: In function 'void dfs(int, int)':
a.cc:22:44: error: expected ')' before ';' token
   22 |         for(int i=0;i<G[current].size();i++;)
      |            ~                               ^
      |                                            )
a.cc:22:45: error: expected primary-expression before ')' token
   22 |         for(int i=0;i<G[current].size();i++;)
      |                                             ^
Language: C++

#include<iostream>
#include<vector>
#include<set>
using namespace std;

#define MAX 100000

vector <int> G[MAX];
int N;
bool visited[MAX];
int prenum[MAX],parent[MAX],lowest[MAX],timer;

void dfs(int current,int prev)
{
	prenum[current]=lowest[current]=timer;
	timer++;
	
	visited[current]=true;
	
	int next;
	
	for(int i=0;i<G[current].size();i++)
	{
		next=G[current][i];
		if(!visited[next])
		{
			parent[next]=current;
			dfs(next,current);
			
			lowest[current]=min(lowest[currnt],lowest[next]);
		}
		else if(next!=prev)
		{
			lowest[current]=min(lowest[current],prenum[next]);
		}
	}
}

void art_points()
{
	for(int i=0;i<N;i++)visited[i]=false;
	timer=1;
	dfs(0,-1);
	set<int> ap;
	int np=0;
	for(int i=1;i<N;i++)
	{
		int p=parent[i];
		if(p==0)np++;
		else if(prenum[p]<=lowest[i])ap.insert(p);
	}
	if(np>1)ap.insert(0);
	for(set<int>::iterator it=ap.begin();it!=ap.end();it++)cout<<*it<<endl;
}

int main()
{
	int m;
	cin>>N>>m;
	
	for(int i=0;i<m;i++)
	{
		int s,t;
		cin>>s>>t;
		G[s].push_back(t);
		G[t].push_back(s);
	}
	art_points();
	
	return 0;
}

Compiler output:
a.cc: In function 'void dfs(int, int)':
a.cc:30:52: error: 'currnt' was not declared in this scope; did you mean 'current'?
   30 |                         lowest[current]=min(lowest[currnt],lowest[next]);
      |                                                    ^~~~~~
      |                                                    current
Language: C++

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <limits>
#include <random>
#include <complex>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#include <iomanip>
using namespace std;
 
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define RREP(i,n) for(int (i)=(int)(n)-1;i>=0;i--)
#define REMOVE(Itr,n) (Itr).erase(remove((Itr).begin(),(Itr).end(),n),(Itr).end())
typedef long long ll;

struct LowLink {
    
    vector < vector < int > > G;
    vector < int > ord, low;
    vector < bool > used;
    vector < pair < int, int > > bridge;
    vector < int > articulation_point;
    const int INF = 1145141919;
    
    LowLink (int n) : G(n), ord(n), low(n), used(n) {}
    
    void add_edge(int a, int b) {
        G[a].push_back(b);
        G[b].push_back(a);
    }
    
    void build(int root) {
        fill(low.begin(), low.end(), INF);
        fill(used.begin(), used.end(), false);
        dfs(root, 0, 1);
    }
    
    int dfs(int v, int prev, int cnt) {
        if (used[v]) return low[v];
        used[v] = true;
        low[v] = ord[v] = cnt;
        int min_low = cnt;
        bool isArticulation = false;
        for (int i = 0; i < G[v].size(); i++) {
            if (G[v][i] != prev) {
                int low_nxt = dfs(G[v][i], v, cnt + 1);
                min_low = min(min_low, low_nxt);
                if (ord[v] < low_nxt) {
                    bridge.push_back(make_pair(v, G[v][i]));
                }
                if (G[v].size() >= 2 && low_nxt >= cnt) {
                    isArticulation = true;
                }
            }
        }
        if (isArticulation) {
            articulation_point.push_back(v);
        }
        return low[v] = min_low;
    }
    
};
int main() {

    int V,E; cin >> V >> E;
    LowLink inst(100010);

    REP(i,E) {
        int a,b; cin >> a >> b;
        inst.add(a, b);
    }

    inst.build(0);

    REP(i,inst.articulation_point.size()) {
        cout << inst.articulation_point[i] << endl;
    }

    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:83:14: error: 'struct LowLink' has no member named 'add'
   83 |         inst.add(a, b);
      |              ^~~