Problem:
 Score : 100 points    Problem Statement Takahashi is going to set a 3 -character password.  How many possible passwords are there if each of its characters must be a digit between 1 and N (inclusive)?      Constraints  1 \leq N \leq 9  N is an integer.         Input Input is given from Standard Input in the following format:  N       Output Print the number of possible passwords.        Sample Input 1 2      Sample Output 1 8  There are eight possible passwords: 111 , 112 , 121 , 122 , 211 , 212 , 221 , and 222 .       Sample Input 2 1      Sample Output 2 1  There is only one possible password if you can only use one kind of character.

Solution (Python):
a = int(input())
print(a**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
print(int(input()) ** 3)

Solution (Python):
n = int(input())
print(pow(n,3))

Solution (Python):

n = int(input())

print(n*n*n)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
n1 = int(input())

r1 = n1 * n1 * n1

print(r1)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):


import sys
from pprint import pprint

def solve(n):
   print(n**3)

if __name__ == '__main__':
  n = int(sys.stdin.readline().strip())
  solve(n)

Solution (Python):
inp = int(input())
print(inp*inp*inp)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n=int(input())
print(n*n*n)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
import sys
input = sys.stdin.readline
n = int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
num = int(input())
print(pow(num,3))

Solution (Python):
N = int(input())

print(N*N*N)

Solution (Python):
print(int(input())**3)

Solution (Python):
a = int(input())
print(a**3)

Solution (Python):


n = int(input())

print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


def main():
    n = int(input())
    print(n ** 3)




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())

print(N ** 3)

Solution (Python):
n = int(input())
print(n * n * n)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
I=int(input())

print(I*I*I)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = input()
n = int(n)
print(n ** 3)

Solution (Python):
n = int(input())
answer = n ** 3
print(answer)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
def A():
    print(int(input())**3)

A()

Solution (Python):
a=int(input())
print(a*a*a)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    print(N ** 3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n=int(input())
print(n*n*n)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
n = int(input())

print(n*n*n)

Solution (Python):
print(int(input())**3)

Solution (Python):

N = int(input())

print(N*N*N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print( int(input())**3 )

Solution (Python):
n = int(input())
print(n * n * n)

Solution (Python):
N = int(input())

print(N * N * N)

Solution (Python):
n = int(input())

print(n*n*n)

Solution (Python):
n = int(input())
print(int(n**3))

Solution (Python):
N = int(input().strip())
print(N*N*N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):



N = int(input())

print(N*N*N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):

import sys


def solve(N: int):
    print(N**3)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

Solution (Python):

"""
Created on Sat Sep  7 20:54:13 2019

@author: doppe
"""

n = int(input())

print(pow(n, 3))

Solution (Python):
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy




def main():
    N = int(input())
    print(N**3)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

answer = n * n * n

print(answer)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
a=int(input())
b = a**3
print(b)

Solution (Python):
A = int(input())

print(pow(A,3))

Solution (Python):
N = int(input())

print(N*N*N)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):

import sys


def solve(N: int):
    print(N**3)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):

n = int(input())
a = n * n * n
print(a)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N=int(input())

print(N**3)

Solution (Python):
from collections import defaultdict
from heapq import heappush, heappop, heapify
from bisect import bisect_left

class Solution:
    def main(self):
        N = int(input())
        print(N**3)


if __name__ == '__main__':
    Solution().main()

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):


print(int(input())**3)

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
N=int(input())
print(N*N*N)

Solution (Python):
N = int(input())
ans = N**3

print(ans)

Solution (Python):
def main():
    n = int(input())
    print(n ** 3)

if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):

import sys


def solve(N: int):
    print(N ** 3)



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())

print(N * N * N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
s = n**3
print(s)

Solution (Python):
n=int(input())

print(n**3)

Solution (Python):
a=int(input());print(a**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())

print(n * n * n)

Solution (Python):
n=int(input())
print(n*n*n)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
n = int(input())

ans = n ** 3

print(ans)

Solution (Python):
print((int(input()))**3)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
def LILI(n): return [LI() for _ in range(n)]
INF = 10 ** 18
MOD = 10 ** 9 + 7

def main(): 
    N = II()
    ans = 1
    for i in range(3):
        ans *= N

    print(ans)

main()

Solution (Python):
N = int(input())
ans=N**3
print(ans)

Solution (Python):
a = int(input())

a = a* a* a

print(a)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
a = int(input())
ans = a*a*a
print(ans)

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
n = int(input())
ans = n**3
print(ans)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N * N * N)

Solution (Python):
def resolve():
    n = int(input())
    print(n ** 3)



resolve()

Solution (Python):
def main():
    N = int(input())

    print(N*N*N)
main()

Solution (Python):
n=int(input())

print(n**3)

Solution (Python):
N = int(input())
ans = N**3
print(ans)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print((int(input()))**3)

Solution (Python):
print(int(input()) ** 3)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
while True:
    try:
        N = int(input())
        print(N**3)
    except:
        break

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
def p_a():
    i = int(input())
    print(i ** 3)


if __name__ == '__main__':
    p_a()

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
import collections as c
ip = lambda : map(int, input().split())

N = int(input())
print(N**3)

Solution (Python):
N = int(raw_input())

print N**3

Solution (Python):
N = int(input())

print(N ** 3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N * N * N)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(pow(n,3))

Solution (Python):
n=int(input())
print(n*n*n)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(raw_input().strip())

print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
N = int(input())

print(N ** 3)

Solution (Python):
n = int(input())

ans = n**3
print(ans)

Solution (Python):
import sys


def input():
    return sys.stdin.readline()[:-1]


def main():
    N = int(input())
    print(N**3)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

print (n**3)

Solution (Python):

N = int(input())
print(N ** 3)

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):

def main():
    N = int(input())
    print(N*N*N)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):


n=int(input())

print(pow(n,3))

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):

n = int(input())
print(n**3)

Solution (Python):
n=int(input())

print(n**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n=int(input())
print(n*n*n)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())

print(n*n*n)

Solution (Python):
print(int(input())**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
def main(): 
    
    N = int(input())

    print(N ** 3)
    
if __name__ == "__main__":
    main()

Solution (Python):
if __name__ == "__main__":
    N = int(input())
    print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect
import heapq


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

x = list(map(int, input().split()))

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""


N= int(input())

    
def main(): 
    print(N**3)
                
                
                
            
            
                

    
if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input())**3)

Solution (Python):


n = int(input())

ans = n ** 3
print(ans)

Solution (Python):
i = int(input())
print(i**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
s = input()
n=int(s)
print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
a = int(input())
print(a*a*a)

Solution (Python):
input = raw_input


s = int(input())
print(s**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
n = int(input())

print(n*n*n)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
n=int(input())

print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N =int(input())
print(N**3)

Solution (Python):
def solve():
  import sys
  import math

  sys.setrecursionlimit(10**7)
  readline=sys.stdin.readline

  print(int(input())**3)


if __name__ == '__main__':
  solve()

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n=int(input())
print(int(n**3))

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
import sys
input = sys.stdin.readline


def main(n):
    return n**3


if __name__ == "__main__":
    n = int(input())
    print(main(n))

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())
print(str(N ** 3))

Solution (Python):
a = int(input())
b = pow(a, 3)
print(int(b))

Solution (Python):
n = int(input())

print(n ** 3)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
a=int(input())
print(a**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
n=int(input())
ans=n**3
print(ans)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
def main():    
    n = int(input())
    print(n**3)
    
if __name__ == '__main__':
    main()

Solution (Python):
print(int(input())**3)

Solution (Python):
from sys import stdin


def main():
    N = int(stdin.readline().rstrip())
    print(N ** 3)


if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
print(int(input()) ** 3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input()) ** 3)

Solution (Python):
N = int(input())
ans = N * N * N
print(ans)

Solution (Python):
num = int(input())

result = num **3
print(result)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N ** 3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N*N*N)

Solution (Python):


import sys

class APassword:
    def solve(self):
        n = int(input())
        print(n ** 3)

solver = APassword()
input = sys.stdin.readline

solver.solve()

Solution (Python):
N=int(input())
ans=0
ans=N**3
print(ans)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):

import sys


def solve(N: int):
    print(N ** 3)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
print(int(input()) ** 3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())

print(n ** 3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
N=int(input())


print(N**3)

Solution (Python):
N = int(input())
ans = N**3

print(ans)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):

N = int(input())

print(N * N * N)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input()) ** 3)

Solution (Python):

import sys,copy
input = sys.stdin.readline


n = int(input())
print(n*n*n)

Solution (Python):


N = int(input())

print(N*N*N)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
def f_a():
    n = int(input())
    print(n**3)

if __name__ == "__main__":
    f_a()

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
def func():
    N = int(input())
    print(N**3)

if __name__ == '__main__':
    func()

Solution (Python):
n = int(input())

print(n ** 3)

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())
print(n * n * n)

Solution (Python):
print(int(input())**3)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N):
    return N**3


def main():
    N = read_int()
    print(slv(N))


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())

print(N * N *N )

Solution (Python):


if __name__ == '__main__':
    n = int(input())
    print(n**3)

Solution (Python):
N = int(input())
out = N * N * N
print(out)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
from sys import stdin

def main():
    N = int(input())
    print(N ** 3)

input = lambda: stdin.readline()[:-1]
main()

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):
def main():
    N = int(input())
    print(N**3)

if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
print(N * N * N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n= int(input())
print(n**3)

Solution (Python):


def main():
    N = int(input())
    print(N**3)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

print(n ** 3)

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
n = int(input())
print(n * n * n)

Solution (Python):
import sys
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

n = ni()
print(n**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
import numpy as np
N=int(input())
print(N**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
n=int(input())

print(n**3)

Solution (Python):
def main():
    N = int(input())
    print(N*N*N)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
a = int(input())
print(a**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N = int(input())

print(N*N*N)

Solution (Python):
n = int(input())

print(n**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N*N*N)

Solution (Python):
N = int(input())

print(N * N * N)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
import sys
input=sys.stdin.readline

def main():
    N = int(input())
    print(N**3)
     
if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())





ans=0

ans=N*N*N





print(str(ans))

Solution (Python):
n = int(input())
print(n*n*n)

Solution (Python):
N = int(input())
print(N*N*N)

Solution (Python):




n = int(input())


ans = n ** 3


print(ans)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):



def solve(N):
    ans = N**3
    return ans


if __name__ == '__main__':
    N = int(input())

    ans = solve(N)

    print(ans)

Solution (Python):
print(int(input())**3)

Solution (Python):
n=int(input())
print(n**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
N = int(input())

print(N**3)

Solution (Python):

import sys
INF = float("inf")


def solve(N: int):
    print(N**3)
    return


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print(n ** 3)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
N = int(input())
print(N ** 3)

Solution (Python):
N=int(input())

print(N**3)

Solution (Python):
N = int(input())

print(N*N*N)

Solution (Python):

N = int(input())

Ans = N ** 3

print(Ans)

Solution (Python):

n = int(input())
print(n*n*n)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    n = II()
    print(n*n*n)
solve()

Solution (Python):
N = int(input())
print(N**3)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
n=int(input())
print(n*n*n)

Solution (Python):
N=int(input())
print(N**3)

Solution (Python):
print(int(input())**3)

Solution (Python):
n = int(input())
print(n**3)

Solution (Python):
print(int(input())**3)