#include <fstream>
using namespace std;

char N[1005];
long len;

char N1[3000];
char N2[3000];
long len1;
long len2;

char N12[3000];
long len12;

char NF[3000];
long lenf;

void Substract(char *from,char *to,char x,long &len)
{
    char c = 0;
    long a = 0;
    while ((c > 0) || (a < len))
    {
        to[a] = from[a] - x - c;
        c = 0;
        if (to[a] < 0)
        {
            to[a] += 10;
            c = 1;
        }
        a += 1;
    }
}

void Multiply(char *from,char x,long &len)
{
    char c = 0;
    long a = 0;
    while ((c > 0) || (a < len))
    {
        from[a] = from[a] * x + c;
        c = from[a] / 10;
        from[a] %= 10;

        a += 1;
    }
    len = a;
}

void Add(char *a,char *b,char *c,long l1,long l2,long &l3)
{
    char k = 0;
    long p = 0;
    while ((k > 0) || (p < l1) || (p < l2))
    {
        c[p] = a[p] + b[p] + k;
        k = c[p] / 10;
        c[p] %= 10;

        p += 1;
    }
    l3 = p;
}

void VecMul(char *a,char *b,char *c,long l1,long l2,long &l3)
{
    char k = 0;
    for (long x = 0;x < l1;x += 1)
    {
        for (long y = 0;y < l2;y += 1)
        {
            c[x + y] += a[x] * b[y] + k;
            k = c[x + y] / 10;
            c[x + y] %= 10;
        }
    }
    l3 = l1 + l2 + 2;
}

int main(void)
{
    fstream fin("sarpe.in",ios::in);
    fstream fout("sarpe.out",ios::out);

    fin >> N;
    for (long a = 0;a < 1005;a += 1)
    {
        if (N[a] == 0)
        {
            len = a;
            break;
        }
        else
        {
            N[a] -= '0';
        }
    }

    for (long a = 0;a < (len >> 1);a += 1)
    {
        char c = N[a];
        N[a] = N[len - a - 1];
        N[len - a - 1] = c;
    }

    if ((len == 1) && (N[0] == 1))
    {
        fout << 2;
    }
    else
    {
        len1 = len;
        len2 = len;
        Substract(N,N1,1,len1);
        Substract(N,N2,2,len2);
        VecMul(N1,N2,N12,len1,len2,len12);
        Multiply(N12,2,len12);
        Multiply(N,4,len);
        Add(N,N12,NF,len,len12,lenf);

        long a = lenf - 1;
        while (NF[a] == 0)
        {
            a -= 1;
        }
        for (;a >= 0;a -= 1)
        {
            fout << ((int)(NF[a]));
        }

        //fout << ((4 * N) + (2 * (N - 1) * (N - 2)));
    }

    fin.close();
    fout.close();
    return 0;
}