Problem:


Score : 100 points

Problem Statement

Given an integer a as input, print the value a + a^2 + a^3.

Constraints

1 \leq a \leq 10

a is an integer.

Input

Input is given from Standard Input in the following format:

a

Output

Print the value a + a^2 + a^3 as an integer.

Sample Input 1

2

Sample Output 1

14

When a = 2, we have a + a^2 + a^3 = 2 + 2^2 + 2^3 = 2 + 4 + 8 = 14.

Print the answer as an input. Outputs such as 14.0 will be judged as incorrect.

Sample Input 2

10

Sample Output 2

1110



Sample input:
2


Sample output:
14

Submission status: Accepted

Solution code:
n = int(input())
answer = n + (n*n) + (n*n*n)
print(answer)

Submission status: Accepted

Solution code:
a = int ( input().strip() ) ;
print ( a + a * a + a * a * a ) ;

Submission status: Accepted

Solution code:
a=int(input())

print(int(a+(a**2)+(a**3)))

Submission status: Accepted

Solution code:
n = int(input())
print(n + (n ** 2) + (n ** 3))

Submission status: Accepted

Solution code:
a = int(input())

print(int(a + a ** 2 + a ** 3))

Submission status: Accepted

Solution code:
a = int(input())
res = a
for i in range(2, 4):
  res += a**i
print(res)

Submission status: Accepted

Solution code:
a = int(input())
ans = 0
for i in range(3):
    ans += a ** (i + 1)

print(ans)

Submission status: Accepted

Solution code:
from sys import stdin
a = int(stdin.readline().rstrip())
print(a+a**2+a**3)

Submission status: Accepted

Solution code:
def resolve():
    a = int(input())
    print(a + a**2 + a**3)

resolve()

Submission status: Accepted

Solution code:
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
print(n+n**2+n**3)

Submission status: Accepted

Solution code:

a = int(input())

print(a + a * a + a * a * a)

Submission status: Accepted

Solution code:
a = int(input())

def calc(a):
  return a + a**2 + a**3

print(calc(a))

Submission status: Accepted

Solution code:
a = int(input())  
print(int(a+a**2+a**3))

Submission status: Accepted

Solution code:
A = int(input())

result = 0

result = A + A**2 + A**3

print(result)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
@author: H_Hoshigi
"""
def main():
    a = int(input())
    print(a + a*a + a*a*a)

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#A
a = int(input())
print(a+a**2 + a**3)

Submission status: Accepted

Solution code:
import numpy as np
import math
import scipy as sp
import queue
import collections

MOD = 10 ** 9 + 7
INF = 10 ** 9

def main(kwargs):
    a = kwargs["a"]
    res = a + a ** 2 + a ** 3
    return res

if __name__ == "__main__":
    kwargs = {}

    cin = input().split()
    kwargs["a"] = [int(i) for i in cin][0]

    cout = main(kwargs)
    print(cout)

Submission status: Accepted

Solution code:
a=int(input())
kotae=a+a**2+a**3
print(kotae)

Submission status: Accepted

Solution code:
# coding: utf-8

import math
import re
import numpy as np
import copy

#読み込む
a = int(input())

ans = a + a**2 + a**3

print(ans)

Submission status: Accepted

Solution code:
a=int(input())
print(a+(a*a)+(a*a*a))

Submission status: Accepted

Solution code:
a = int(input())

print(a + (a * a) + (a * a * a))

Submission status: Accepted

Solution code:
A = int(input())
print(A + A ** 2 + A ** 3)

Submission status: Accepted

Solution code:
a = int(input())
ans = a**3 + a**2 + a
print(ans)

Submission status: Accepted

Solution code:
#!/usr/bin/env python
import os
import operator
from collections import defaultdict
import sys
from io import BytesIO, IOBase
import bisect

# def power(x, p):
#     res = 1
#     while p:
#         if p & 1:
#             res = res * x % 1000000007
#         x = x * x % 1000000007
#         p >>= 1
#     return res;

def main():
    # for _ in range(int(input())):
    #     n=int(input())
    #     n,k=map(int,input().split())
    #     arr=[int(k) for k in input().split()]
    n=int(input())
    # n,k=map(int,input().split())
    # arr=[int(k) for k in input().split()]
    print(n+n**2+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")


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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a=int(input())
ans=a+a**2+a**3
print(ans)

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  # log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


def ceil(a, b): return (a + b - 1) // b


inf = float('inf')
mod = 10 ** 9 + 7


def pprint(*A):
    for a in A:     print(*a, sep='\n')


def INT_(n): return int(n) - 1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [I() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():
    a = I()
    print(a + a ** 2 + a ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    a = int(input().strip())
    print(a+a*a+a*a*a)

Submission status: Accepted

Solution code:
a = int(input())
ans = 0

for i in range(1, 4):
    ans += a ** i

print(ans)

Submission status: Accepted

Solution code:
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# import numpy as np
sys.setrecursionlimit(int(pow(10,6)))
# sys.stdin = open("sort.in", "r")
# sys.stdout = open("out.txt", "w")
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]

# @lru_cache(None)
t=1
# t=int(input())
for _ in range(t):
    a=l()[0]
    print(a+a*a+a*a*a)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
input = sys.stdin.readline


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

Submission status: Accepted

Solution code:
a = int(input())
ans = a + (a**2) + (a**3)

print(ans)

Submission status: Accepted

Solution code:
def main():
        a = int(input())

        ans = a + a**2 + a**3

        return int(ans)

if __name__=="__main__":
        ans = main()
        print(ans)

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
# from fractions import gcd

MOD = 10 ** 9 + 7
# MOD = 998244353
# sys.setrecursionlimit(10**8)


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

Submission status: Accepted

Solution code:
a = int(input())

print(int(a + a **2 + a**3))

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline


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


def main():
    a = int(input())
    print(a + a ** 2 + a ** 3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a = int(input())
an = a + (a*a) + (a*a*a)
print(an)

Submission status: Accepted

Solution code:
a = int(input())
print(a + a**2 + a **3)

Submission status: Accepted

Solution code:
a = int(input())
print(a * (1 + a + a**2))

Submission status: Accepted

Solution code:
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def X(): return list(input())
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

a = int(input())
aa = a**2
aaa = a**3
print(a+aa+aaa)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

Submission status: Accepted

Solution code:
x = int(input())

x2=x*x

x3=x2*x

x=x+x2+x3

print(x)

Submission status: Accepted

Solution code:
def main():
    a = int(input().rstrip())
    print(a+a**2+a**3)
    
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
N = int(input())
ans = N + N **2 + N **3
print(ans)

Submission status: Accepted

Solution code:
a = int(input())
a = a +a*a+a*a*a
print(a)

Submission status: Accepted

Solution code:
a = int(input())
print(a + a*a + a ** 3)

Submission status: Accepted

Solution code:
def readinput():
    a=int(input())
    return a

def main(a):
    ans=a+a**2+a**3
    return ans

if __name__=='__main__':
    a=readinput()
    ans=main(a)
    print(ans)

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    # 10**6
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp

#

class UnionFindEx:
    def __init__(self, size):
        #正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   #負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    #サイズ更新
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


def main():
    a =ii()
    print(a+a**2+a**3)



main()

Submission status: Accepted

Solution code:
a = int(input())

answer = a + a ** 2 + a ** 3

print(answer)

Submission status: Accepted

Solution code:
a = int(input())

print(pow(a,2) + pow(a,3) + a)

Submission status: Accepted

Solution code:
import sys

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
    a = I()
    ans = a + a**2 + a**3
    print(ans)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')

a = int(input())

ans = a + a ** 2 + a ** 3
print(ans)

Submission status: Accepted

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
# from fractions import gcd
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from functools import reduce
from bisect import bisect_left, insort_left
from heapq import heapify, heappush, heappop

INPUT = lambda: sys.stdin.readline().rstrip()
INT = lambda: int(INPUT())
MAP = lambda: map(int, INPUT().split())
S_MAP = lambda: map(str, INPUT().split())
LIST = lambda: list(map(int, INPUT().split()))
S_LIST = lambda: list(map(str, INPUT().split()))
ZIP = lambda: zip(*(MAP() for _ in range(n)))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7


def main():
    a = INT()
    print(a + a ** 2 + a **3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A = int(input())
print(A**3 + A**2 + A)

Submission status: Accepted

Solution code:
a=int(input())
s=a+a**2+a**3
print(s)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

a=int(input())
ans=a**3+a**2+a
print(int(ans))

Submission status: Accepted

Solution code:
S = int(input())
print(S + (S **2) + (S**3))

Submission status: Accepted

Solution code:
a = int(input())
b = a*a
c = b*a
print(int(a+b+c))

Submission status: Accepted

Solution code:
a=int(input())	
print(a+a**2+a**3)

Submission status: Accepted

Solution code:
a = int(input())
b = a + a ** 2 + a ** 3
print(b)

Submission status: Accepted

Solution code:
import sys

a = int(sys.stdin.readline().strip())
print(a + a**2 + a**3)

Submission status: Accepted

Solution code:
a = int(input())
if 1<=a<=10:
    print(int(a+a**2+a**3))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

def main():
    a = int(input())
    ans = a + a**2 + a ** 3
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from collections import deque
import math

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

a = int(input())
print(a**3 + a**2 + a)

Submission status: Accepted

Solution code:
A = int(input())
ans = A + A ** 2 + A ** 3
print(ans)

Submission status: Accepted

Solution code:
#K = int(input())
#X = list(map(int, input().split()))
#s = input().split()
S = int(input())

a = S + S*S + S*S*S

print(a)

Submission status: Accepted

Solution code:
a = int(input())

print(a + a **2 + a ** 3)

Submission status: Accepted

Solution code:
import sys
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 7)

a = int(input())

a = a+a*a+a**3

print(a)

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    print(a + pow(a,2) + pow(a,3))

main()

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
a = ii()

print(a + a**2 + a**3)

Submission status: Accepted

Solution code:
n = int(input())
print(n+ n**2 + n**3)

Submission status: Accepted

Solution code:
n = int(input())
res = n + n**2 + n**3
print(res)

Submission status: Accepted

Solution code:
import sys

def read_int():
    l = sys.stdin.readline().rstrip('\n').split(' ')
    return int(l[0])

def read_int_list():
    l = sys.stdin.readline().rstrip('\n').split(' ')                                                  
    return [int(i) for i in l]                                                                        

a = read_int()                                                                                        

print(a+a**2+a**3)

Submission status: Accepted

Solution code:
a = int(input())
import math
print(int(a+math.pow(a,2)+math.pow(a,3)))

Submission status: Accepted

Solution code:
N = int(input())

print(N + N **2 + N **3)

Submission status: Accepted

Solution code:
#coding:utf-8

a = int(input())

print('{}'.format(int(a+a**2+a**3)))

Submission status: Accepted

Solution code:
n=int(input())
print(n+pow(n,2)+pow(n,3))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
a = int(input())

print(a+a**2+a**3)

Submission status: Accepted

Solution code:
n = int(input())
print(n + (n ** 2) + (n ** 3))

Submission status: Accepted

Solution code:
a=int(input())
print(a+a**2+a**3)

Submission status: Accepted

Solution code:
# 初期入力
import sys
input = sys.stdin.readline
a = int(input())
ans =a +a**2 +a**3
print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

def solve():
    a = int(input())
    return str(a + a**2 + a**3)

if __name__ == '__main__':
    print(solve())

Submission status: Accepted

Solution code:
a :int = int(input())
ans = a + a**2 + a**3
print(ans)

Submission status: Accepted

Solution code:
a = int(input())

ans = a**3 + a**2 + a
print(ans)

Submission status: Accepted

Solution code:
import math


#n=map(int,input().split())
a=int(input())
print(a+a*a+a*a*a)

Submission status: Accepted

Solution code:
a=int(input())
print((a)+(a*a)+(a**3))

Submission status: Accepted

Solution code:
a = int(input())

print( a + a**2 + a**3 )

Submission status: Accepted

Solution code:

def resolve():
  a = int(input())
  print(a+a**2+a**3)

if __name__ == "__main__":
  resolve()

Submission status: Accepted

Solution code:
from math import *

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

Submission status: Accepted

Solution code:

def main():
    a = int(input())
    print(a+a*a+a*a*a)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#-*-coding:utf-8-*-

import sys

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a = int(input())
b = a*a
c = a*a*a
print(a+b+c)

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().rstrip()


from collections import deque  #listよりdequeの方が両端へのアクセスは計算量が少ない
def main():
    n = int(input())
    print(n + n * n + n * n * n)

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
a = int(input())

print(a + a**2 + a**3 )

Submission status: Accepted

Solution code:
a = int(input())

ans = a + a*a + a*a*a
print(ans)

Submission status: Accepted

Solution code:
A = int(input())

print(A + A**2 + A**3)

Submission status: Accepted

Solution code:
# coding: utf-8
s=int(input())

ans = s + s**2 + s**3
print(ans)

Submission status: Accepted

Solution code:
a = int(input())

result = a + pow(a, 2) + pow(a, 3)

print(result)

Submission status: Accepted

Solution code:
a = int(input())

ans = a + a * a + a ** 3
print(ans)

Submission status: Accepted

Solution code:
a=int(input())
print(int(a**3+a**2+a))

Submission status: Accepted

Solution code:
#! /usr/bin/env python3

import sys
import numpy as np
int1 = lambda x: int(x) - 1
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(500000)

a = int(readline())

print(int(a + pow(a, 2) + pow(a, 3)))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys

input = sys.stdin.readline


def S():
    return input().rstrip()


def I():
    return int(input())


def MI():
    return map(int, input().split())


a = I()
print(a + a ** 2 + a ** 3)

Submission status: Accepted

Solution code:
from sys import stdin
a = int(stdin.readline().rstrip())

print(a+a**2+a**3)

Submission status: Accepted

Solution code:
a=int(input())

calc=a+pow(a,2)+pow(a,3)
print(calc)

Submission status: Accepted

Solution code:
#!python3

import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

def resolve():
    a = int(input())
    print(a+a**2+a**3)


if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
A = int(input())
ans = A + A * A + A * A * A
print(ans)

Submission status: Accepted

Solution code:
a  = [int(v) for v in input().split()][0]
print(str(a+a**2+a**3))

Submission status: Accepted

Solution code:
def main():
  a = int(input())
  print(a + a**2 + a**3)

if __name__ == "__main__":
    main()

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a = int(input())

ans = 0
for i in range(1, 4):
    ans += a ** i

print(ans)

Submission status: Accepted

Solution code:
#-*- using:utf-8 -*-

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

Submission status: Accepted

Solution code:
'''
.append(要素) リストに要素を追加
.extend(リスト) リストを連結する
.insert(場所,要素) 指定した場所に要素追加
del 配列名[場所]
-1で末尾で末尾から一つ前

sort()
sorted(reverse=true)

配列の初期化
配列名=[a]*n+[b]*m

Decimal()
'''

from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby
import bisect
import copy
import math
from functools import reduce
from operator import mul
from collections import Counter
import itertools
import fractions
import sys

a = int(stdin.readline().rstrip())
print(a**3+a**2+a)

Submission status: Accepted

Solution code:
n = int(input())
print(n + n**2 + n **3)

Submission status: Accepted

Solution code:
n = int(input())
print(n+n*n+(n*n*n))

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
from decimal import Decimal
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())


a = I()
print(a**3 + a**2 + a)

Submission status: Accepted

Solution code:
a = int(input())
print((a) + (a ** 2) + (a ** 3))

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    ans = a + a**2 + a**3
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a = int(input())
print(a * (1 + (a * (1 + a))))

Submission status: Accepted

Solution code:
n = int(input())
a2 = n*n
a3 = a2*n

print(n+a2+a3)

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    print(a + a*a + a*a*a)

main()

Submission status: Accepted

Solution code:
a=int(input());print(a+(a**2)+(a**3))

Submission status: Accepted

Solution code:
x = int(input())
print(int(x+x*x+x*x*x))

Submission status: Accepted

Solution code:
#172A

a=int(input())

print(a+a**2+a**3)

Submission status: Accepted

Solution code:
def main():
    a = int(input())

    return a + a * a + a * a * a

print(main())

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# coding: utf-8

# In[1]:


a = int(input())
print(a + a**2 + a**3)


# In[ ]:

Submission status: Accepted

Solution code:
import queue
from math import floor
from decimal import Decimal

A = int(input())

print(A+A**2+A**3)

Submission status: Accepted

Solution code:

def main():
    a = int(input())
    print(a+a**2+a**3)

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
a=int(input())
print(a*(1+a+a**2))

Submission status: Accepted

Solution code:
import sys
import numpy as np
import math
import collections
from collections import deque 
from functools import reduce

# input = sys.stdin.readline

a = int(input())
print(a+a**2+a**3)

Submission status: Accepted

Solution code:
n = int(input())
print(n+n**2+n**3)

Submission status: Accepted

Solution code:
a = int(input())
print(a+a**2 + a**3)

Submission status: Accepted

Solution code:
def resolve():
    inp = input()
    a = int(inp)

    r = a**3+a**2+a

    print(r)

resolve()

Submission status: Accepted

Solution code:
a = int(input())
print(int(a + pow(a, 2) + pow(a, 3)))

Submission status: Accepted

Solution code:
a=int(input(''))
print((a**3)+(a**2)+a)

Submission status: Accepted

Solution code:


def main():
    A = int(input())
    print(A+pow(A,2)+pow(A,3))




if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    a = int(input())
    print(a + a ** 2 + a ** 3)

if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
from sys import stdin
a = int(stdin.readline())
print(a+a**2+a**3)

Submission status: Accepted

Solution code:
def main():
    import sys
    def input():
        return sys.stdin.readline()[:-1]
    a=int(input())
    print(a+a**2+a**3)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    ans = int(a + (a**2) + (a**3))
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys
import math
import itertools as it
def I():return int(sys.stdin.readline().replace("\n",""))
def I2():return map(int,sys.stdin.readline().replace("\n","").split())
def S():return str(sys.stdin.readline().replace("\n",""))
def L():return list(sys.stdin.readline().replace("\n",""))
def Intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":
    a = I()
    print(a+a**2+a**3)

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    print(a + a**2 + a**3)



main()

Submission status: Accepted

Solution code:
t = int(input())
print(t + t**2 + t**3)

Submission status: Accepted

Solution code:
a = int(input())
ans = a + a ** 2 + a ** 3

print(ans)

Submission status: Accepted

Solution code:
##172
a = int(input())

print(a+a**2+a**3)

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
def main():
    a = int(input())
    print(a+a**2+a**3)
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    a = int(input())
    ans = a + a**2 + a**3
    print(ans)
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from sys import stdin
input = stdin.readline

a = int(input())

print(a + a**2 + a**3)

Submission status: Accepted

Solution code:
a = int(raw_input())
print(a+a*a+a*a*a)

Submission status: Accepted

Solution code:
###==================================================
### import
#import bisect
#from collections import Counter, deque, defaultdict
#from copy import deepcopy
#from functools import reduce, lru_cache
#from heapq import heappush, heappop
#import itertools
#import math
#import string
import sys
### stdin
def input(): return sys.stdin.readline()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip("\n") for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]
### stdout
def OutH(lst): print(*lst)
def OutV(lst): print(*lst, sep="\n")
### setting
sys.setrecursionlimit(10 ** 6)
### utils
int1 = lambda x: int(x) - 1
### constants
INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)
###---------------------------------------------------

a = iIn()

print(a + a**2 + a**3)

Submission status: Accepted

Solution code:
#!/usr/bin/env python

def main():
    a = int(input())
    print(a + a**2 + a**3)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
a = int(input())

print(a + a**2 + a**3)

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

a, = map(int,readline().split())

print(a+a**2+a**3)

Submission status: Accepted

Solution code:
inpl = lambda: list(map(int,input().split()))
a = int(input())
print(a + a*a + a*a*a)

Submission status: Accepted

Solution code:
'''
Created on 2020/06/27

@author: harurun
'''
a = int(input())
print(a+a**2+a**3)

Submission status: Accepted

Solution code:
N = int(input())
print(N + N*N + N*N*N)

Submission status: Accepted

Solution code:
a = int(input())

ans = a + pow(a, 2) + pow(a, 3)

print(ans)

Submission status: Accepted

Solution code:
a = int(input())
print(a+ a**2 + a**3)