Language: C++

# include <iostream>
# include <sstream>
# include <cstdio>
# include <cstdlib>
# include <algorithm>
# include <string>
# include <cstring>
# include <cmath>
# include <stack>
# include <queue>
# include <vector>
# include <list>
# include <map>
# include <set>
# include <deque>
# include <iterator>
# include <functional>
# include <bitset>
# include <climits>
# include <ctime>
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define odd(x) (x&1)
typedef long long ll;
typedef long double ld;
const ll oo = /*2 * 1000 * 1000 * 1000*/0x3f3f3f3f;
const int _cnt = 1000 * 1000;
const int _p = 1000 * 1000 * 1000 + 7;
ll o(ll x) { return x%_p; }
int gcd(int a, int b) { return b ? gcd(b, a%b) : a; }
//ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
int lcm(int a, int b) { return a / gcd(a, b)*b; }
using namespace std;

void file_put() {
	freopen("filename.in", "r", stdin);
	freopen("filename.out", "w", stdout);
}

const int N = 80;

class BigNumber {

private:

	int x[N], sgn = 0;

public:

	void shrink();

	BigNumber();

	BigNumber(const int &sgn, const int len);

	BigNumber(const int &t);

	BigNumber(const BigNumber & B);

	BigNumber(const string & s);

	void print(int num = 0) const;

	void swap(BigNumber &B);

	int size() const;

	BigNumber &operator=(const BigNumber &B);

	BigNumber &operator=(const int &A);

	BigNumber &operator=(const string & A);

	friend ostream &operator<<(ostream & output, BigNumber & B);

	friend istream &operator >> (istream & input, BigNumber & B);

	BigNumber operator+() const;

	BigNumber operator-() const;

	friend int compare(const BigNumber & A, const BigNumber & B);

	friend bool operator>(const BigNumber &A, const BigNumber &B);

	friend bool operator>=(const BigNumber &A, const BigNumber &B);

	friend bool operator<(const BigNumber &A, const BigNumber &B);

	friend bool operator<=(const BigNumber &A, const BigNumber &B);

	friend bool operator==(const BigNumber &A, const BigNumber &B);

	friend bool operator!=(const BigNumber &A, const BigNumber &B);

	friend bool operator>(const BigNumber &A, const int &B);

	friend bool operator>=(const BigNumber &A, const int &B);

	friend bool operator<(const BigNumber &A, const int &B);

	friend bool operator<=(const BigNumber &A, const int &B);

	friend bool operator==(const BigNumber &A, const int &B);

	friend bool operator!=(const BigNumber &A, const int &B);

	friend bool operator>(const int &A, const BigNumber &B);

	friend bool operator>=(const int &A, const BigNumber &B);

	friend bool operator<(const int &A, const BigNumber &B);

	friend bool operator<=(const int &A, const BigNumber &B);

	friend bool operator==(const int &A, const BigNumber &B);

	friend bool operator!=(const int &A, const BigNumber &B);

	bool operator!() const;

	friend BigNumber abs(const BigNumber &B);

	friend BigNumber operator + (const BigNumber &A, const BigNumber &B);

	friend BigNumber operator - (const BigNumber &A, const BigNumber &B);

	friend BigNumber operator * (const BigNumber &A, const BigNumber &B);

	friend BigNumber operator + (const BigNumber &A, const int &B);

	friend BigNumber operator - (const BigNumber &A, const int &B);

	friend BigNumber operator * (const BigNumber &A, const int &B);

	friend BigNumber operator + (const int &A, const BigNumber &B);

	friend BigNumber operator - (const int &A, const BigNumber &B);

	friend BigNumber operator * (const int &A, const BigNumber &B);

	BigNumber& operator +=(const BigNumber &A);

	BigNumber& operator -=(const BigNumber &A);

	BigNumber& operator *=(const BigNumber &A);

	BigNumber& operator +=(const int &A);

	BigNumber& operator -=(const int &A);

	BigNumber& operator *=(const int &A);

	BigNumber& operator ++();

	BigNumber operator ++(int);

	BigNumber& operator --();

	BigNumber operator --(int);
};


void BigNumber::shrink() {
	while (x[0] && !x[x[0]]) x[0]--;
	if (!x[0]) {
		this->x[0] = 1;
		this->sgn = 0;
	}
}

BigNumber::BigNumber() {
	sgn = 0;
	memset(x, 0, sizeof(x));
	x[0] = 1;
}

BigNumber::BigNumber(const int &sgn, const int len) {
	this->sgn = sgn;
	memset(x, 0, sizeof(x));
	x[0] = len;
}

BigNumber::BigNumber(const int &t) {
	int n = t;
	if (n > 0) sgn = 1; else
		if (n < 0) sgn = -1; else
			sgn = 0;
	n = abs(n);
	memset(x, 0, sizeof(x));
	if (!n) {
		this->x[0] = 1;
		return;
	}
	while (n) {
		x[++x[0]] = n % 10;
		n /= 10;
	}
	this->shrink();
}

BigNumber::BigNumber(const BigNumber & B) {
	this->sgn = B.sgn;
	memset(this->x, 0, sizeof(this->x));
	for (int i = 0; i <= B.x[0]; i++) this->x[i] = B.x[i];
	this->shrink();
}

BigNumber::BigNumber(const string & s) {
	string st = s;
	if (st[0] == '-') {
		this->sgn = -1;
		st.erase(st.begin());
	}
	else
		this->sgn = 1;
	memset(this->x, 0, sizeof(this->x));
	for (int i = st.length() - 1; i >= 0; i--) this->x[++x[0]] = st[i] - '0';
	if (this->x[0] == 1 && this->x[1] == 0) this->sgn = 0;
	//this->shrink();
}

void BigNumber::print(int num) const {
	if (this->sgn == -1 && this->x[x[0]] != 0) printf("-");
	if (num && this->sgn == 1 && this->x[x[0]] != 0) printf("+");
	BigNumber B = *this;
	B.shrink();
	for (int i = B.x[0]; i >= 1; i--) printf("%d", B.x[i]);
}

void BigNumber::swap(BigNumber &B) {
	std::swap(*this, B);
}

int BigNumber::size() const { return this->x[0]; }

BigNumber & BigNumber ::operator=(const BigNumber &B) {
	this->sgn = B.sgn;
	memset(this->x, 0, sizeof(this->x));
	for (int i = 0; i <= B.x[0]; i++) this->x[i] = B.x[i];
	return *this;
}

BigNumber & BigNumber ::operator=(const int &A) {
	BigNumber B = A;
	this->sgn = B.sgn;
	memset(this->x, 0, sizeof(this->x));
	for (int i = 0; i <= B.x[0]; i++) this->x[i] = B.x[i];
	return *this;
}

BigNumber & BigNumber ::operator=(const string &A) {
	BigNumber B = A;
	this->sgn = B.sgn;
	memset(this->x, 0, sizeof(this->x));
	for (int i = 0; i <= B.x[0]; i++) this->x[i] = B.x[i];
	return *this;
}

ostream &operator<<(ostream & output, BigNumber & B) {
	B.shrink();
	if (B.sgn == -1) output << '-';
	for (int i = B.x[0]; i >= 1; i--) output << B.x[i];
	return output;
}

istream &operator >> (istream & input, BigNumber & B) {
	string st;
	input >> st;
	B = BigNumber(st);
	return input;
}

BigNumber BigNumber ::operator+() const {
	return *this;
}

BigNumber BigNumber ::operator-() const {
	BigNumber t = *this;
	t.sgn = -t.sgn;
	return t;
}

int compare(const BigNumber & A, const BigNumber & B) {
	if (A.sgn > B.sgn) return 1;
	if (A.sgn < B.sgn) return -1;
	if (A.x[0] > B.x[0]) return A.sgn;
	if (A.x[0] < B.x[0]) return -A.sgn;
	for (int i = A.x[0]; i >= 1; i--) {
		if (A.x[i] > B.x[i]) return A.sgn;
		if (A.x[i] < B.x[i]) return -A.sgn;
	}
	return 0;
}

bool operator>(const BigNumber &A, const BigNumber &B) {
	return compare(A, B) == 1;
}

bool operator>=(const BigNumber &A, const BigNumber &B) {
	return compare(A, B) != -1;
}

bool operator<(const BigNumber &A, const BigNumber &B) {
	return compare(A, B) == -1;
}

bool operator<=(const BigNumber &A, const BigNumber &B) {
	return compare(A, B) != 1;
}

bool operator==(const BigNumber &A, const BigNumber &B) {
	return compare(A, B) == 0;
}

bool operator!=(const BigNumber &A, const BigNumber &B) {
	return compare(A, B) != 0;
}

bool operator>(const BigNumber &A, const int &B) {
	return compare(A, B) == 1;
}

bool operator>=(const BigNumber &A, const int &B) {
	return compare(A, B) != -1;
}

bool operator<(const BigNumber &A, const int &B) {
	return compare(A, B) == -1;
}

bool operator<=(const BigNumber &A, const int &B) {
	return compare(A, B) != 1;
}

bool operator==(const BigNumber &A, const int &B) {
	return compare(A, B) == 0;
}

bool operator!=(const BigNumber &A, const int &B) {
	return compare(A, B) != 0;
}

bool operator>(const int &A, const BigNumber &B) {
	return compare(A, B) == 1;
}

bool operator>=(const int &A, const BigNumber &B) {
	return compare(A, B) != -1;
}

bool operator<(const int &A, const BigNumber &B) {
	return compare(A, B) == -1;
}

bool operator<=(const int &A, const BigNumber &B) {
	return compare(A, B) != 1;
}

bool operator==(const int &A, const BigNumber &B) {
	return compare(A, B) == 0;
}

bool operator!=(const int &A, const BigNumber &B) {
	return compare(A, B) != 0;
}

bool BigNumber ::operator!() const { return *this == 0; }

BigNumber abs(const BigNumber &B) { return (B >= 0) ? (+B) : (-B); }

BigNumber operator + (const BigNumber &A, const BigNumber &B) {
	if (!A) return B;
	if (!B) return A;
	if (A.sgn == B.sgn) {
		BigNumber C(A.sgn, max(A.x[0], B.x[0]));
		for (int i = 1; i <= C.x[0]; i++) C.x[i] = A.x[i] + B.x[i];
		for (int i = 1; i <= C.x[0]; i++) C.x[i + 1] += C.x[i] / 10, C.x[i] %= 10;
		C.x[0] += (C.x[C.x[0] + 1] > 0);
		return C;
	}
	if (A < 0) return B - (-A); else return A - (-B);
}

BigNumber operator - (const BigNumber &A, const BigNumber &B) {
	if (!A) return -B;
	if (!B) return A;
	if (A < 0) return -(-A + B);
	if (B < 0) return A + (-B);
	if (A < B) return -(B - A);
	BigNumber C(1, A.x[0]);
	for (int i = 1; i <= C.x[0]; i++) C.x[i] = A.x[i] - B.x[i];
	for (int i = 1; i <= C.x[0]; i++) {
		C.x[i + 1] -= (C.x[i] < 0);
		C.x[i] += (C.x[i] < 0) * 10;
	}
	while (C.x[0] > 1 && !C.x[C.x[0]]) C.x[0]--;
	C.sgn = !(C.x[0] == 1 && !C.x[1]);
	return C;
}

BigNumber operator * (const BigNumber &A, const BigNumber &B) {
	if (!A || !B) return 0;
	BigNumber C(A.sgn*B.sgn, A.x[0] + B.x[0] - 1);
	for (int i = 1; i <= A.x[0]; i++)
		for (int j = 1; j <= B.x[0]; j++)
			C.x[i + j - 1] += A.x[i] * B.x[j];
	for (int i = 1; i <= C.x[0]; i++) C.x[i + 1] += C.x[i] / 10, C.x[i] %= 10;
	while (C.x[C.x[0] + 1]) {
		C.x[0]++;
		C.x[C.x[0] + 1] += C.x[C.x[0]] / 10;
		C.x[C.x[0]] %= 10;
	}
	return C;
}

BigNumber operator + (const BigNumber &A, const int &B) { return A + BigNumber(B); }

BigNumber operator - (const BigNumber &A, const int &B) { return A - BigNumber(B); }

BigNumber operator * (const BigNumber &A, const int &B) { return A * BigNumber(B); }

BigNumber operator + (const int &A, const BigNumber &B) { return BigNumber(A) + B; }

BigNumber operator - (const int &A, const BigNumber &B) { return BigNumber(A) - B; }

BigNumber operator * (const int &A, const BigNumber &B) { return BigNumber(A) * B; }

BigNumber& BigNumber ::operator +=(const BigNumber &A) { return *this = *this + A; }

BigNumber& BigNumber ::operator -=(const BigNumber &A) { return *this = *this - A; }

BigNumber& BigNumber ::operator *=(const BigNumber &A) { return *this = *this * A; }

BigNumber& BigNumber ::operator +=(const int &A) { return *this = *this + A; }

BigNumber& BigNumber ::operator -=(const int &A) { return *this = *this - A; }

BigNumber& BigNumber ::operator *=(const int &A) { return *this = *this * A; }

BigNumber& BigNumber ::operator ++() { return *this += 1; }

BigNumber BigNumber ::operator ++(int) { return *this += 1; }

BigNumber& BigNumber ::operator --() { return *this -= 1; }

BigNumber BigNumber ::operator --(int) { return *this -= 1; }



const int MAXN = 200005;
const ll INF = 9223372036854775807;
struct Edge {
	int v;
	int cost;
	Edge(int _v = 0, int _cost = 0) :v(_v), cost(_cost) {}
};
vector<Edge>E[MAXN];
void addedge(int u, int v, int w) {
	E[u].push_back(Edge(v, w));
}
bool vis[MAXN];
int cnt[MAXN];
BigNumber dist[MAXN];
bool SPFA(int start, int n) {
	memset(vis, false, sizeof(vis));
	for (int i = 1; i <= n; i++)dist[i] = "92233720368547758079225807";
	vis[start] = true;
	dist[start] = 0;
	queue<int>que;
	while (!que.empty())que.pop();
	que.push(start);
	memset(cnt, 0, sizeof(cnt));
	cnt[start] = 1;
	while (!que.empty()) {
		int u = que.front();
		que.pop();
		vis[u] = false;
		for (int i = 0; i<E[u].size(); i++) {
			int v = E[u][i].v;
			if (dist[v]>dist[u] + E[u][i].cost) {
				dist[v] = dist[u] + E[u][i].cost;
				if (!vis[v]) {
					vis[v] = true;
					que.push(v);
					if (++cnt[v]>n)return false;
				}
			}
		}
	}
	return true;
}

int n, m, a, b, c;

int main() {
	//file_put();

	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d%d%d", &a, &b, &c);
		addedge(a, b, -c);
	}
	if (!SPFA(1, n)) printf("inf\n"); else cout << -dist[n] << endl;

	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:504:53: error: no match for 'operator<<' (operand types are 'std::ostream' {aka 'std::basic_ostream<char>'} and 'BigNumber')
  504 |         if (!SPFA(1, n)) printf("inf\n"); else cout << -dist[n] << endl;
      |                                                ~~~~ ^~ ~~~~~~~~
      |                                                |       |
      |                                                |       BigNumber
      |                                                std::ostream {aka std::basic_ostream<char>}
a.cc:260:10: note: candidate: 'std::ostream& operator<<(std::ostream&, BigNumber&)' (near match)
  260 | ostream &operator<<(ostream & output, BigNumber & B) {
      |          ^~~~~~~~
a.cc:260:10: note:   conversion of argument 2 would be ill-formed:
a.cc:504:56: error: cannot bind non-const lvalue reference of type 'BigNumber&' to an rvalue of type 'BigNumber'
  504 |         if (!SPFA(1, n)) printf("inf\n"); else cout << -dist[n] << endl;
      |                                                        ^~~~~~~~
In file included from /usr/include/c++/14/iostream:41,
                 from a.cc:1:
/usr/include/c++/14/ostream:116:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(__ostream_type& (*)(__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  116 |       operator<<(__ostream_type& (*__pf)(__ostream_type&))
      |       ^~~~~~~~
/usr/include/c++/14/ostream:116:36: note:   no known conversion for argument 1 from 'BigNumber' to 'std::basic_ostream<char>::__ostream_type& (*)(std::basic_ostream<char>::__ostream_type&)' {aka 'std::basic_ostream<char>& (*)(std::basic_ostream<char>&)'}
  116 |       operator<<(__ostream_type& (*__pf)(__ostream_type&))
      |                  ~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/ostream:125:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(__ios_type& (*)(__ios_type&)) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>; __ios_type = std::basic_ios<char>]'
  125 |       operator<<(__ios_type& (*__pf)(__ios_type&))
      |       ^~~~~~~~
/usr/include/c++/14/ostream:125:32: note:   no known conversion for argument 1 from 'BigNumber' to 'std::basic_ostream<char>::__ios_type& (*)(std::basic_ostream<char>::__ios_type&)' {aka 'std::basic_ios<char>& (*)(std::basic_ios<char>&)'}
  125 |       operator<<(__ios_type& (*__pf)(__ios_type&))
      |                  ~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~
/usr/include/c++/14/ostream:135:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  135 |       operator<<(ios_base& (*__pf) (ios_base&))
      |       ^~~~~~~~
/usr/include/c++/14/ostream:135:30: note:   no known conversion for argument 1 from 'BigNumber' to 'std::ios_base& (*)(std::ios_base&)'
  135 |       operator<<(ios_base& (*__pf) (ios_base&))
      |                  ~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
/usr/include/c++/14/ostream:174:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  174 |       operator<<(long __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:174:23: note:   no known conversion for argument 1 from 'BigNumber' to 'long int'
  174 |       operator<<(long __n)
      |                  ~~~~~^~~
/usr/include/c++/14/ostream:178:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  178 |       operator<<(unsigned long __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:178:32: note:   no known conversion for argument 1 from 'BigNumber' to 'long unsigned int'
  178 |       operator<<(unsigned long __n)
      |                  ~~~~~~~~~~~~~~^~~
/usr/include/c++/14/ostream:182:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  182 |       operator<<(bool __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:182:23: note:   no known conversion for argument 1 from 'BigNumber' to 'bool'
  182 |       operator<<(bool __n)
      |                  ~~~~~^~~
In file included from /usr/include/c++/14/ostream:1022:
/usr/include/c++/14/bits/ostream.tcc:96:5: note: candidate: 'std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char; _Traits = std::char_traits<char>]'
   96 |     basic_ostream<_CharT, _Traits>::
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/ostream.tcc:97:22: note:   no known conversion for argument 1 from 'BigNumber' to 'short int'
   97 |     operator<<(short __n)
      |                ~~~~~~^~~
/usr/include/c++/14/ostream:189:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  189 |       operator<<(unsigned short __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:189:33: note:   no known conversion for argument 1 from 'BigNumber' to 'short unsigned int'
  189 |       operator<<(unsigned short __n)
      |                  ~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/bits/ostream.tcc:110:5: note: candidate: 'std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char; _Traits = std::char_traits<char>]'
  110 |     basic_ostream<_CharT, _Traits>::
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/ostream.tcc:111:20: note:   no known conversion for argument 1 from 'BigNumber' to 'int'
  111 |     operator<<(int __n)
      |                ~~~~^~~
/usr/include/c++/14/ostream:200:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  200 |       operator<<(unsigned int __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:200:31: note:   no known conversion for argument 1 from 'BigNumber' to 'unsigned int'
  200 |       operator<<(unsigned int __n)
      |                  ~~~~~~~~~~~~~^~~
/usr/include/c++/14/ostream:211:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  211 |       operator<<(long long __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:211:28: note:   no known conversion for argument 1 from 'BigNumber' to 'long long int'
  211 |       operator<<(long long __n)
      |                  ~~~~~~~~~~^~~
/usr/include/c++/14/ostream:215:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  215 |       operator<<(unsigned long long __n)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:215:37: note:   no known conversion for argument 1 from 'BigNumber' to 'long long unsigned int'
  215 |       operator<<(unsigned long long __n)
      |                  ~~~~~~~~~~~~~~~~~~~^~~
/usr/include/c++/14/ostream:231:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  231 |       operator<<(double __f)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:231:25: note:   no known conversion for argument 1 from 'BigNumber' to 'double'
  231 |       operator<<(double __f)
      |                  ~~~~~~~^~~
/usr/include/c++/14/ostream:235:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  235 |       operator<<(float __f)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:235:24: note:   no known conversion for argument 1 from 'BigNumber' to 'float'
  235 |       operator<<(float __f)
      |                  ~~~~~~^~~
/usr/include/c++/14/ostream:243:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  243 |       operator<<(long double __f)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:243:30: note:   no known conversion for argument 1 from 'BigNumber' to 'long double'
  243 |       operator<<(long double __f)
      |                  ~~~~~~~~~~~~^~~
/usr/include/c++/14/ostream:301:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char; _Traits = std::char_traits<char>; __ostream_type = std::basic_ostream<char>]'
  301 |       operator<<(const void* __p)
      |       ^~~~~~~~
/usr/include/c++/14/ostream:301:30: note:   no known conversion for argument 1 from 'BigNumber' to 'const void*'
  301 |       operator<<(const void* __p)
      |                  ~~~~~~~~~~~~^~~
/usr/include/c++/14/ostream:306:7: note: candidate: 'std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::nul