Language: C++

import sys
import math
import collections
import itertools
import array
import inspect

# Set max recursion limit
sys.setrecursionlimit(1000000)


# Debug output
def chkprint(*args):
    names = {
        id(v): k
        for k, v in inspect.currentframe().f_back.f_locals.items()
    }
    print(', '.join(
        names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))


# Binary converter
def to_bin(x):
    return bin(x)[2:]


def li_input():
    return [int(_) for _ in sys.stdin.readline().split()]


def gcd(n, m):
    if n % m == 0:
        return m
    else:
        return gcd(m, n % m)


def gcd_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = gcd(v, L[i])

    return v


def lcm(n, m):
    return (n * m) // gcd(n, m)


def lcm_list(L):
    v = L[0]

    for i in range(1, len(L)):
        v = lcm(v, L[i])

    return v

def comb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2, r + 1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p - 1, r, p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

def bisearch(L, target):
    low = 0
    high = len(L) - 1
    
    while low <= high:
        mid = (low + high) // 2
        guess = L[mid]
        if guess == target:
            return True
        elif guess < target:
            low = mid + 1
        elif guess > target:
            high = mid - 1
    if guess != target:
        return False

# --------------------------------------------

dp = None


def main():
    print(int(input())**2)


main()


Compiler output:
a.cc:8:3: error: invalid preprocessing directive #Set
    8 | # Set max recursion limit
      |   ^~~
a.cc:12:3: error: invalid preprocessing directive #Debug
   12 | # Debug output
      |   ^~~~~
a.cc:18:11: warning: multi-character character constant [-Wmultichar]
   18 |     print(', '.join(
      |           ^~~~
a.cc:19:30: warning: trigraph ??' ignored, use -trigraphs to enable [-Wtrigraphs]
   19 |         names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))
a.cc:19:28: warning: multi-character character constant [-Wmultichar]
   19 |         names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))
      |                            ^~~~~
a.cc:19:37: warning: multi-character character constant [-Wmultichar]
   19 |         names.get(id(arg), '???') + ' = ' + repr(arg) for arg in args))
      |                                     ^~~~~
a.cc:22:3: error: invalid preprocessing directive #Binary
   22 | # Binary converter
      |   ^~~~~~
a.cc:98:3: error: invalid preprocessing directive #--
   98 | # --------------------------------------------
      |   ^~
a.cc:1:1: error: 'import' does not name a type
    1 | import sys
      | ^~~~~~
a.cc:1:1: note: C++20 'import' only available with '-fmodules-ts'
a.cc:18:10: error: expected constructor, destructor, or type conversion before '(' token
   18 |     print(', '.join(
      |          ^