Language: C++

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;

using ll = long long;
using ld = long double;
using db = double;
using str = string;

using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;

using vi = vector<int>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;

using indexed_set = tree<pair<int, int>,null_type,less<pair<int, int>>,rb_tree_tag,
	tree_order_statistics_node_update>;

#define mp make_pair
#define f first
#define s second
#define sz(x) (int)(x).size()
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend() //
#define rsz resize
#define ins insert //
#define ft front() //
#define bk back()
#define pf push_front //
#define pb push_back
#define eb emplace_back //
#define lb lower_bound //
#define ub upper_bound //

#define for(i,a,b) for (int i = (a); i < (b); ++i)
#define f0r(i,a) for(i,0,a)
#define rof(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define r0f(i,a) rof(i,0,a)
#define trav(a,x) for (auto& a: x)

const int mod = 1e9+7; // 998244353;
const int mx = 2e5+5; //
const int iinf = 1e9;
const ll inf = 1e18; //
const ld pi = acos((ld)-1);
const int xd[4] = {1,0,-1,0}, yd[4] = {0,1,0,-1}; //
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count()); //
//
template<class t> bool ckmin(t& a, const t& b) { 
	return b < a ? a = b, 1 : 0; }
template<class t> bool ckmax(t& a, const t& b) { //
	return a < b ? a = b, 1 : 0; } //
constexpr int pct(int x) { return __builtin_popcount(x); } //
constexpr int bits(int x) { return 31-__builtin_clz(x); } // floor(log2(x)) //
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
// ignore
ll half(ll x) { return fdiv(x,2); }

template<class t, class u> t fsttrue(t lo, t hi, u f) {
	hi ++; assert(lo <= hi); // assuming f is increasing
	while (lo < hi) { // find first index such that f is true 
		t mid = half(lo+hi);
		f(mid) ? hi = mid : lo = mid+1; 
	} 
	return lo;
}
template<class t, class u> t lsttrue(t lo, t hi, u f) {
	lo --; assert(lo <= hi); // assuming f is decreasing
	while (lo < hi) { // find first index such that f is true 
		t mid = half(lo+hi+1);
		f(mid) ? lo = mid : hi = mid-1;
	} 
	return lo;
}
template<class t> void remdup(vector<t>& v) { 
	sort(all(v)); v.erase(unique(all(v)),end(v)); }
// ignore

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
 
    size_t operator()(uint64_t x) const {
        static const uint64_t fixed_random = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + fixed_random);
    }
};

// input
template<class a> void re(complex<a>& c);
template<class a, class b> void re(pair<a,b>& p);
template<class a> void re(vector<a>& v);
template<class a, size_t sz> void re(array<a,sz>& a);

template<class t> void re(t& x) { cin >> x; }
void re(db& d) { str t; re(t); d = stod(t); }
void re(ld& d) { str t; re(t); d = stold(t); }
template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }

template<class a> void re(complex<a>& c) { a a,b; re(a,b); c = {a,b}; }
template<class a, class b> void re(pair<a,b>& p) { re(p.f,p.s); }
template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }

// to_string
#define ts to_string
str ts(char c) { return str(1,c); }
str ts(const char* s) { return (str)s; }
str ts(str s) { return s; }
str ts(bool b) { 
	#ifdef local
		return b ? "true" : "false"; 
	#else 
		return ts((int)b);
	#endif
}
template<class a> str ts(complex<a> c) { 
	stringstream ss; ss << c; return ss.str(); }
str ts(vector<bool> v) {
	str res = "{"; f0r(i,sz(v)) res += char('0'+v[i]);
	res += "}"; return res; }
template<size_t sz> str ts(bitset<sz> b) {
	str res = ""; f0r(i,sz) res += char('0'+b[i]);
	return res; }
template<class a, class b> str ts(pair<a,b> p);
template<class t> str ts(t v) { // containers with begin(), end()
	#ifdef local
		bool fst = 1; str res = "{";
		for (const auto& x: v) {
			if (!fst) res += ", ";
			fst = 0; res += ts(x);
		}
		res += "}"; return res;
	#else
		bool fst = 1; str res = "";
		for (const auto& x: v) {
			if (!fst) res += " ";
			fst = 0; res += ts(x);
		}
		return res;

	#endif
}
template<class a, class b> str ts(pair<a,b> p) {
	#ifdef local
		return "("+ts(p.f)+", "+ts(p.s)+")"; 
	#else
		return ts(p.f)+" "+ts(p.s);
	#endif
}

// output
template<class a> void pr(a x) { cout << ts(x); }
template<class h, class... t> void pr(const h& h, const t&... t) { 
	pr(h); pr(t...); }
void ps() { pr("\n"); } // print w/ spaces
template<class h, class... t> void ps(const h& h, const t&... t) { 
	pr(h); if (sizeof...(t)) pr(" "); ps(t...); }

// debug
void dbg() { cerr << "]" << endl; }
template<class h, class... t> void dbg(h h, t... t) {
	cerr << ts(h); if (sizeof...(t)) cerr << ", ";
	dbg(t...); }
#ifdef local // compile with -dlocal, chk -> fake assert
	#define dbg(...) cerr << "line(" << __line__ << ") -> [" << #__va_args__ << "]: [", dbg(__va_args__)
	#define chk(...) if (!(__va_args__)) cerr << "line(" << __line__ << ") -> function(" \
		 << __function__  << ") -> chk failed: (" << #__va_args__ << ")" << "\n", exit(0);
#else
	#define dbg(...) 0
	#define chk(...) 0
#endif

// file i/o
void setin(str s) { freopen(s.c_str(),"r",stdin); }
void setout(str s) { freopen(s.c_str(),"w",stdout); }
void unsyncio() { ios_base::sync_with_stdio(0); cin.tie(0); }
void setio(str s = "") {
	unsyncio();
	// cin.exceptions(cin.failbit); 
	// throws exception when do smth illegal
	// ex. try to read letter into int
	if (sz(s)) { setin(s+".in"), setout(s+".out"); } // for usaco
}

template<class fun>
class y_combinator_result {
	fun fun_;
public:
	template<class t>
	explicit y_combinator_result(t &&fun): fun_(std::forward<t>(fun)) {}
 
	template<class ...args>
	decltype(auto) operator()(args &&...args) {
		return fun_(std::ref(*this), std::forward<args>(args)...);
	}
};
 
template<class fun>
decltype(auto) y_combinator(fun &&fun) {
	return y_combinator_result<std::decay_t<fun>>(std::forward<fun>(fun));
}

struct mi {
 	int v; explicit operator int() const { return v; }
	mi() { v = 0; }
	mi(ll _v):v(_v%mod) { v += (v<0)*mod; }
};
mi& operator+=(mi& a, mi b) {
	if ((a.v += b.v) >= mod) a.v -= mod;
	return a; }
mi& operator-=(mi& a, mi b) {
	if ((a.v -= b.v) < 0) a.v += mod;
	return a; }
mi operator+(mi a, mi b) { return a += b; }
mi operator-(mi a, mi b) { return a -= b; }
mi operator*(mi a, mi b) { return mi((ll)a.v*b.v); }
mi& operator*=(mi& a, mi b) { return a = a*b; }
mi pow(mi a, ll p) { assert(p >= 0); // asserts are important!
	return p==0?1:pow(a*a,p/2)*(p&1?a:1); }
mi inv(mi a) { assert(a.v != 0); return pow(a,mod-2); }
mi operator/(mi a, mi b) { return a*inv(b); }

int main(){
	setio();
	int n, x, t;
	cin >> n >> x >> t;
	cout << ((n + x - 1) / x) * t << endl;
}

Compiler output:
a.cc:115:51: error: macro "for" requires 3 arguments, but only 1 given
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                   ^
a.cc:42:9: note: macro "for" defined here
   42 | #define for(i,a,b) for (int i = (a); i < (b); ++i)
      |         ^~~
a.cc:116:64: error: macro "for" requires 3 arguments, but only 1 given
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                ^
a.cc:42:9: note: macro "for" defined here
   42 | #define for(i,a,b) for (int i = (a); i < (b); ++i)
      |         ^~~
a.cc:149:38: error: macro "for" requires 3 arguments, but only 1 given
  149 |                 for (const auto& x: v) {
      |                                      ^
a.cc:42:9: note: macro "for" defined here
   42 | #define for(i,a,b) for (int i = (a); i < (b); ++i)
      |         ^~~
a.cc:52:10: error: 'const ld pi' redeclared as different kind of entity
   52 | const ld pi = acos((ld)-1);
      |          ^~
a.cc:11:7: note: previous declaration 'using pi = struct std::pair<int, int>'
   11 | using pi = pair<int, int>;
      |       ^~
a.cc:106:51: error: declaration of 'std::array<_Tp, _Nm>& a' shadows template parameter
  106 | template<class a, size_t sz> void re(array<a,sz>& a);
      |                                      ~~~~~~~~~~~~~^
a.cc:106:10: note: template parameter 'a' declared here
  106 | template<class a, size_t sz> void re(array<a,sz>& a);
      |          ^~~~~
a.cc:111:42: error: declaration of 'h& h' shadows template parameter
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |                                       ~~~^
a.cc:111:10: note: template parameter 'h' declared here
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |          ^~~~~
a.cc:111:47: error: declaration of 't& ... t' shadows template parameter
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |                                             ~~^~~~~
a.cc:111:19: note: template parameter 't' declared here
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |                   ^~~~~
a.cc: In function 'void re(h&, t& ...)':
a.cc:111:47: error: declaration of 't& ... t' shadows template parameter
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |                                             ~~^~~~~
a.cc:111:19: note: template parameter 't' declared here
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |                   ^~~~~
a.cc:111:42: error: declaration of 'h& h' shadows template parameter
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |                                       ~~~^
a.cc:111:10: note: template parameter 'h' declared here
  111 | template<class h, class... t> void re(h& h, t&... t) { re(h); re(t...); }
      |          ^~~~~
a.cc: In function 'void re(std::complex<_Tp>&)':
a.cc:113:46: error: declaration of 'a a' shadows template parameter
  113 | template<class a> void re(complex<a>& c) { a a,b; re(a,b); c = {a,b}; }
      |                                              ^
a.cc:113:10: note: template parameter 'a' declared here
  113 | template<class a> void re(complex<a>& c) { a a,b; re(a,b); c = {a,b}; }
      |          ^~~~~
a.cc: In function 'void re(std::vector<_Tp>&)':
a.cc:115:53: error: expected '(' before 're'
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                     ^~
      |                                                     (
a.cc:115:57: error: expected primary-expression before ')' token
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                         ^
a.cc:115:60: error: expected primary-expression before '}' token
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                            ^
a.cc:115:59: error: expected ';' before '}' token
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                           ^~
      |                                                           ;
a.cc:115:60: error: expected primary-expression before '}' token
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                            ^
a.cc:115:59: error: expected ')' before '}' token
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                     ~~    ^~
      |                                                           )
a.cc:115:60: error: expected primary-expression before '}' token
  115 | template<class a> void re(vector<a>& x) { trav(a,x) re(a); }
      |                                                            ^
a.cc: In function 'void re(std::array<_Tp, _Nm>&)':
a.cc:116:66: error: expected '(' before 're'
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                  ^~
      |                                                                  (
a.cc:116:70: error: expected primary-expression before ')' token
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                      ^
a.cc:116:73: error: expected primary-expression before '}' token
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                         ^
a.cc:116:72: error: expected ';' before '}' token
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                        ^~
      |                                                                        ;
a.cc:116:73: error: expected primary-expression before '}' token
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                         ^
a.cc:116:72: error: expected ')' before '}' token
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                  ~~    ^~
      |                                                                        )
a.cc:116:73: error: expected primary-expression before '}' token
  116 | template<class a, size_t sz> void re(array<a,sz>& x) { trav(a,x) re(a); }
      |                                                                         ^
a.cc: In function 'str to_string(t)':
a.cc:149:40: error: expected '(' before '{' token
  149 |                 for (const auto& x: v) {
      |                                        ^
      |                                        (
a.cc:149:40: error: expected primary-expression before '{' token
a.cc:153:17: error: expected primary-expression before 'return'
  153 |                 return res;
      |                 ^~~~~~
a.cc:152:18: error: expected ';' before 'return'
  152 |                 }
      |                  ^
      |                  ;
  153 |                 return res;
      |                 ~~~~~~
a.cc:153:17: error: expected primary-expression before 'return'
  153 |                 return res;
      |                 ^~~~~~
a.cc:152:18: error: expected ')' before 'return'
  152 |                 }
      |                  ^
      |                  )
  153 |                 return res;
      |                 ~~~~~~
a.cc:149:40: note: to match this '('
  149 |                 for (const auto& x: v) {
      |                                        ^
a.cc: At global scope:
a.cc:167:48: error: declaration of 'const h& h' shadows template parameter
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |                                       ~~~~~~~~~^
a.cc:167:10: note: template parameter 'h' declared here
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |          ^~~~~
a.cc:167:59: error: declaration of 'const t& ... t' shadows template parameter
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |                                                   ~~~~~~~~^~~~~
a.cc:167:19: note: template parameter 't' declared here
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |                   ^~~~~
a.cc: In function 'void pr(const h&, const t& ...)':
a.cc:167:59: error: declaration of 'const t& ... t' shadows template parameter
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |                                                   ~~~~~~~~^~~~~
a.cc:167:19: note: template parameter 't' declared here
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |                   ^~~~~
a.cc:167:48: error: declaration of 'const h& h' shadows template parameter
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |                                       ~~~~~~~~~^
a.cc:167:10: note: template parameter 'h' declared here
  167 | template<class h, class... t> void pr(const h& h, const t&... t) {
      |          ^~~~~
a.cc: At global scope:
a.cc:170:48: error: declaration of 'const h& h' shadows template parameter
  170 | template<class h, class... t> void ps(const h& h, const t&... t) {
      |                                       ~~~~~~~~~^
a.cc:170:10: note: template parameter 'h' declared here
  170 | template<class h, class... t> void ps(const h& h, const t&... t) {
      |          ^~~~~
a.cc:170:59: error: declaration of 'const t& ... t' shadows template parameter
  170 | template<class h, class... t> void ps(const h& h, const t&... t) {
      |                                                   ~~~~~~~~^~~~~
a.cc:170:19: