Language: C++


		m_bitFlag += n;
		this->m_bitFlag %= m_upper;
		return *this;
	}
	BitFlag operator-(int n) {
		m_bitFlag -= n;
		return *this;
	}
	BitFlag operator+(BitFlag& b) {
		this->m_bitFlag += b.m_bitFlag;
		this->m_bitFlag %= m_upper;
		return *this;
	}
	BitFlag operator-(BitFlag& b) {
		this->m_bitFlag -= b.m_bitFlag;
		return *this;
	}
 
	bool operator==(BitFlag& comp) {
		return comp.m_bitFlag == this->m_bitFlag ? true : false;
	}
	bool operator!=(BitFlag& comp) {
		return !(*this == comp);
	}
 
	friend ostream& operator<<(ostream& o, const BitFlag& b);
};
 
ostream& operator<<(ostream& o, const BitFlag& b) {
	for (ll i = 0; i < b.m_size; ++i) {
		cout << ((b.m_bitFlag & b.m_exponentiation[i]) == 0 ? false : true);
	}
	return o;
}
 
class Mod {
public:
	static inline ll Add(ll a, ll b) {
		return (a + b) % MOD;
	}
 
	static inline ll Sub(ll a, ll b) {
		ll ans = (a - b) % MOD;
		return (ans < 0) ? (ans + MOD) : ans;
	}
 
	static inline ll Mul(ll a, ll b) {
		return (a * b) % MOD;
	}
	
	static inline ll Div(ll a, ll b) {
		return (a % MOD) * modinv(b, MOD) % MOD;
	}
};
 
inline double distance(Pos p1, Pos p2) {
	return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}
 
inline ull Kaijo(int n) {
	ull ans = 1;
	for (int i = 2; i <= n; ++i) {
		ans *= i;
	}
	return ans;
}
 
template <typename T>
inline int GetKeta(T num) {
	return to_string(num).length();
}
 
void Main();
inline void DebugMain() {
	while (true) {
		Main();
		cout << endl;
	}
}
 
signed main() {
	bool debug = false;
	cin.tie(nullptr);
	ios_base::sync_with_stdio(false);
	cout << fixed << setprecision(15);
 
	if (debug) {
		cout << "\x1b[41m" << "Debug Mode このまま提出すると死" << endl;
	}
	try {
		(debug) ? DebugMain() : Main();
	}
	catch (exception& e) {
		cout << e.what() << endl;
	}
	catch (string& s){
		cout << s << endl;
	}
 
	return 0;
}
 
template <typename T>
inline bool isExistArray(vector<T>& v, T& str) {
	if (v.size() == 0) {
		return false;
	}
	for (string& s : v) {
		if (s == str) {
			return true;
		}
	}
	return false;
}
 
inline int ctoi(char c) {
	return (int)c - 48;
}
 
template <typename T>
inline int Find(vector<T>& v, T n) {
	for (size_t i = 0; i < v.size(); ++i) {
		if (v[i] == n) {
			return i;
		}
	}
	return -1;
}
 
inline bool isSameArray(vector<int>& v1, vector<int>& v2) {
	for (size_t i = 0; i < v1.size(); ++i) {
		if (v1[i] != v2[i]) {
			return false;
		}
	}
	return true;
}
 
inline bool isSeisu(double n) {
 
	if (std::floor(n) == n) {
		return true;
	}
	return false;
}
 
int gcd(int a, int b)
{
	if (a % b == 0)
	{
		return(b);
	}
	else
	{
		return(gcd(b, a % b));
	}
}
 
int lcm(int a, int b)
{
	return a * b / gcd(a, b);
}
 
inline ll Kiriage(ll a, ll b) {
	return (a + (b - 1)) / b;
}
 
template<class T>
inline void container_sort(std::vector<T>& v) {
	std::sort(all(v));
}
template<class T>
inline void container_sort(std::list<T>& v) {
	v.sort();
}
 
template<class T>
inline void Unique(T& v) {
 
	container_sort(v);
	v.erase(
		std::unique(
			v.begin(),
			v.end()),
		v.end()
	);
}
 
inline vector<bool> GetPrimeTable(int n) {
	vector<bool> primeTable(n + 1, true);
	int sqr = (int)sqrt(n);
	primeTable[0] = false; //0は素数じゃない
	primeTable[1] = false; //1は素数じゃない
	for (int i = 2; i <= sqr; ++i) {
		if (primeTable[i]) {
			for (size_t j = i + i; j < primeTable.size(); j += i) {
				primeTable[j] = false;
			}
		}
	}
	return primeTable;
}
 
inline vector<ll> GetPrimeNumbers(int n) {
	vector<bool> primeTable = GetPrimeTable(n);
	vector<ll> result;
	if (n < 2) {
		result;
	}
	result.reserve(n / 2);
	for (size_t i = 0; i < primeTable.size(); ++i) {
		if (primeTable[i]) {
			result.push_back(i);
		}
	}
	result.shrink_to_fit();
	return result;
}
 
inline map<ll, ll> PrimeFact(ull n) {
	ull num = 2;
	map<ll, ll> result;
	while(true) {
		if (n % num == 0) {
			if (result.count(num) == 0) {
				result.insert(pair<ll, ll>{num, 1});
			}
			else {
				result[num]++;
			}
			n /= num;
		}
		else {
			if (++num > sqrt(n)) {
				if (result.size() == 0 || n != 1) {
					result.insert(pair<ll, ll>{n, 1});
				}
				return result;
			}
		}
	}
}
 
void recursive_comb(int* indexes, int s, int rest, std::function<void(int*)> f) {
	if (rest == 0) {
		f(indexes);
	}
	else {
		if (s < 0) return;
		recursive_comb(indexes, s - 1, rest, f);
		indexes[rest - 1] = s;
		recursive_comb(indexes, s - 1, rest - 1, f);
	}
}
 
template <typename T>
inline vector<int> GetBorder(vector<T>& v) {
	T tmp = v[0];
	vector<int> border;
	size_t vSize = v.size();
	border.reserve(vSize / 3); //雑に確保
	for (size_t i = 1; i < vSize; ++i) {
		if (v[i] != tmp) {
			border.push_back(i);
			tmp = v[i];
		}
	}
	return border;
}
 
template <typename T, typename U>
inline vector<int> GetBorder(vector<pair<T, U>>& ps) {
	T tmp = ps[0].first;
	vector<int> border;
	size_t psSize = ps.size();
	border.reserve(psSize / 3); //雑に確保
	for (size_t i = 1; i < psSize; ++i) {
		if (ps[i].first != tmp) {
			border.push_back(i);
			tmp = ps[i].first;
		}
	}
	return border;
}
 
//foreach_comb(n, k, [](int*indexes){
//});
// nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(int*)> f) {
	int* indexes = new int[k];
	recursive_comb(indexes, n - 1, k, f);
}
 
template <typename T>
inline T MultisetPopBack(multiset<T>& m) {
	auto iter = m.end();
	iter--;
	T tmp = *iter;
	m.erase(m.find(*iter));
	return tmp;
}
 
template <typename T>
inline T MultisetPopFront(multiset<T>& m) {
	auto iter = m.begin();
	T tmp = *iter;
	m.erase(m.find(*iter));
 
	return tmp;
}
 
 
inline void Main() {
	Ini(A);
 	long double B;
  	cin >> B;
	int b = B * 100;
	int ab = A * b;
 
	cout << (int)(ab / 100);
}

Compiler output:
a.cc:2:17: error: 'm_bitFlag' does not name a type
    2 |                 m_bitFlag += n;
      |                 ^~~~~~~~~
a.cc:3:17: error: expected unqualified-id before 'this'
    3 |                 this->m_bitFlag %= m_upper;
      |                 ^~~~
a.cc:4:17: error: expected unqualified-id before 'return'
    4 |                 return *this;
      |                 ^~~~~~
a.cc:5:9: error: expected declaration before '}' token
    5 |         }
      |         ^
a.cc:6:9: error: 'BitFlag' does not name a type
    6 |         BitFlag operator-(int n) {
      |         ^~~~~~~
a.cc:10:9: error: 'BitFlag' does not name a type
   10 |         BitFlag operator+(BitFlag& b) {
      |         ^~~~~~~
a.cc:15:9: error: 'BitFlag' does not name a type
   15 |         BitFlag operator-(BitFlag& b) {
      |         ^~~~~~~
a.cc:20:14: error: declaration of 'operator==' as non-function
   20 |         bool operator==(BitFlag& comp) {
      |              ^~~~~~~~
a.cc:20:25: error: 'BitFlag' was not declared in this scope
   20 |         bool operator==(BitFlag& comp) {
      |                         ^~~~~~~
a.cc:20:34: error: 'comp' was not declared in this scope
   20 |         bool operator==(BitFlag& comp) {
      |                                  ^~~~
a.cc:23:14: error: declaration of 'operator!=' as non-function
   23 |         bool operator!=(BitFlag& comp) {
      |              ^~~~~~~~
a.cc:23:25: error: 'BitFlag' was not declared in this scope
   23 |         bool operator!=(BitFlag& comp) {
      |                         ^~~~~~~
a.cc:23:34: error: 'comp' was not declared in this scope
   23 |         bool operator!=(BitFlag& comp) {
      |                                  ^~~~
a.cc:27:9: error: 'friend' used outside of class
   27 |         friend ostream& operator<<(ostream& o, const BitFlag& b);
      |         ^~~~~~
      |         ------
a.cc:27:16: error: 'ostream' does not name a type
   27 |         friend ostream& operator<<(ostream& o, const BitFlag& b);
      |                ^~~~~~~
a.cc:28:1: error: expected declaration before '}' token
   28 | };
      | ^
a.cc:30:1: error: 'ostream' does not name a type
   30 | ostream& operator<<(ostream& o, const BitFlag& b) {
      | ^~~~~~~
a.cc:39:23: error: 'll' does not name a type
   39 |         static inline ll Add(ll a, ll b) {
      |                       ^~
a.cc:43:23: error: 'll' does not name a type
   43 |         static inline ll Sub(ll a, ll b) {
      |                       ^~
a.cc:48:23: error: 'll' does not name a type
   48 |         static inline ll Mul(ll a, ll b) {
      |                       ^~
a.cc:52:23: error: 'll' does not name a type
   52 |         static inline ll Div(ll a, ll b) {
      |                       ^~
a.cc:57:24: error: 'Pos' was not declared in this scope
   57 | inline double distance(Pos p1, Pos p2) {
      |                        ^~~
a.cc:57:32: error: 'Pos' was not declared in this scope
   57 | inline double distance(Pos p1, Pos p2) {
      |                                ^~~
a.cc:57:38: error: expression list treated as compound expression in initializer [-fpermissive]
   57 | inline double distance(Pos p1, Pos p2) {
      |                                      ^
a.cc:61:8: error: 'ull' does not name a type
   61 | inline ull Kaijo(int n) {
      |        ^~~
a.cc: In function 'void DebugMain()':
a.cc:78:17: error: 'cout' was not declared in this scope
   78 |                 cout << endl;
      |                 ^~~~
a.cc:78:25: error: 'endl' was not declared in this scope
   78 |                 cout << endl;
      |                         ^~~~
a.cc: In function 'int main()':
a.cc:84:9: error: 'cin' was not declared in this scope
   84 |         cin.tie(nullptr);
      |         ^~~
a.cc:85:9: error: 'ios_base' has not been declared
   85 |         ios_base::sync_with_stdio(false);
      |         ^~~~~~~~
a.cc:86:9: error: 'cout' was not declared in this scope
   86 |         cout << fixed << setprecision(15);
      |         ^~~~
a.cc:86:17: error: 'fixed' was not declared in this scope
   86 |         cout << fixed << setprecision(15);
      |                 ^~~~~
a.cc:86:26: error: 'setprecision' was not declared in this scope
   86 |         cout << fixed << setprecision(15);
      |                          ^~~~~~~~~~~~
a.cc:89:76: error: 'endl' was not declared in this scope
   89 |                 cout << "\x1b[41m" << "Debug Mode このまま提出すると死" << endl;
      |                                                                            ^~~~
a.cc:94:16: error: 'exception' does not name a type
   94 |         catch (exception& e) {
      |                ^~~~~~~~~
a.cc:95:25: error: 'e' was not declared in this scope
   95 |                 cout << e.what() << endl;
      |                         ^
a.cc:95:37: error: 'endl' was not declared in this scope
   95 |                 cout << e.what() << endl;
      |                                     ^~~~
a.cc:97:16: error: 'string' does not name a type
   97 |         catch (string& s){
      |                ^~~~~~
a.cc:98:25: error: 's' was not declared in this scope
   98 |                 cout << s << endl;
      |                         ^
a.cc:98:30: error: 'endl' was not declared in this scope
   98 |                 cout << s << endl;
      |                              ^~~~
a.cc: At global scope:
a.cc:105:26: error: 'vector' was not declared in this scope
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                          ^~~~~~
a.cc:105:34: error: expected primary-expression before '>' token
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                                  ^
a.cc:105:37: error: 'v' was not declared in this scope
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                                     ^
a.cc:105:41: error: expected primary-expression before '&' token
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                                         ^
a.cc:105:43: error: 'str' was not declared in this scope; did you mean 'std'?
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                                           ^~~
      |                                           std
a.cc:105:46: error: expression list treated as compound expression in initializer [-fpermissive]
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                                              ^
a.cc:105:47: error: expected ';' before '{' token
  105 | inline bool isExistArray(vector<T>& v, T& str) {
      |                                               ^~
      |                                               ;
a.cc:122:17: error: 'vector' was not declared in this scope
  122 | inline int Find(vector<T>& v, T n) {
      |                 ^~~~~~
a.cc:122:25: error: expected primary-expression before '>' token
  122 | inline int Find(vector<T>& v, T n) {
      |                         ^
a.cc:122:28: error: 'v' was not declared in this scope
  122 | inline int Find(vector<T>& v, T n) {
      |                            ^
a.cc:122:33: error: expected primary-expression before 'n'
  122 | inline int Find(vector<T>& v, T n) {
      |                                 ^
a.cc:122:34: error: expression list treated as compound expression in initializer [-fpermissive]
  122 | inline int Find(vector<T>& v, T n) {
      |                                  ^
a.cc:122:35: error: expected ';' before '{' token
  122 | inline int Find(vector<T>& v, T n) {
      |                                   ^~
      |                                   ;
a.cc:131:25: error: 'vector' was not declared in this scope
  131 | inline bool isSameArray(vector<int>& v1, vector<int>& v2) {
      |                         ^~~~~~
a.cc:131:32: error: expected primary-expression before 'int'
  131 | inline bool isSameArray(vector<int>& v1, vector<int>& v2) {
      |                                ^~~
a.cc:131:42: error: 'vector' was not declared in this scope
  131 | inline bool isSameArray(vector<int>& v1, vector<int>& v2) {
      |                                          ^~~~~~
a.cc:131:49: error: expected primary-expression before 'int'
  131 | inline bool isSameArray(vector<int>& v1, vector<int>& v2) {
      |                                                 ^~~
a.cc:131:57: error: expression list treated as compound expression in initializer [-fpermissive]
  131 | inline bool isSameArray(vector<int>& v1, vector<int>& v2) {
      |                                                         ^
a.cc: In function 'bool isSeisu(double)':
a.cc:142:18: error: 'floor' is not a member of 'std'
  142 |         if (std::floor(n) == n) {
      |                  ^~~~~
a.cc: At global scope:
a.cc:165:8: error: 'll' does not name a type
  165 | inline ll Kiriage(ll a, ll b) {
      |        ^~
a.cc:170:13: error: variable or field 'container_sort' declared void
  170 | inline void container_sort(std::vector<T>& v) {
      |             ^~~~~~~~~~~~~~
a.cc:170:33: error: 'vector' is not a member of 'std'
  170 | inline void container_sort(std::vector<T>& v) {
      |                                 ^~~~~~
a.cc:1:1: note: 'std::vector' is defined in header '<vector>'; this is probably fixable by adding '#include <vector>'
  +++ |+#include <vector>
    1 | 
a.cc:170:41: error: expected primary-expression before '>' token
  170 | inline void container_sort(std::vector<T>& v) {
      |                                         ^
a.cc:170:44: error: 'v' was not declared in this scope
  170 | inline void container_sort(std::vector<T>& v) {
      |                                            ^
a.cc:174:13: error: variable or field 'container_sort' declared void
  174 | inline void container_sort(std::list<T>& v) {
      |             ^~~~~~~~~~~~~~
a.cc:174:33: error: 'list' is not a member of 'std'
  174 | inline void container_sort(std::list<T>& v) {
      |                                 ^~~~
a.cc:1:1: note: 'std::list' is defined in header '<list>'; this is probably fixable by adding '#include <list>'
  +++ |+#include <list>
    1 | 
a.cc:174:39: error: expected primary-expression before '>' token
  174 | inline void