#include <iostream>
#include <fstream>
#include <cstring>

using namespace std;

#define Lmax 1024
#define BAZA 10000

class BigInteger{

    public: int n[Lmax];

    BigInteger(){

        memset ( n, 0, sizeof ( n ) );
    }

    inline void operator = ( BigInteger A ){

        memcpy ( n, A.n, sizeof ( A.n ) );
    }

    inline void operator = ( int A ){

        memset ( n, 0, sizeof ( n ) );

        if ( A == 0 ){

            n[ ++n[0] ] = 0;
        }

        for ( ; A > 0; A /= BAZA )
            n[ ++n[0] ] = A % BAZA;
    }

    inline void operator = ( char sir[] ){

        int L = strlen ( sir );

        for ( int i = L - 1; i >= 0; i -= 4 ){

            n[ ++n[0] ] = sir[i] - '0';

            if ( i > 0 ) n[ n[0] ] += ( ( sir[i - 1]- '0' ) * 10 );
            if ( i > 1 ) n[ n[0] ] += ( ( sir[i - 2] - '0' ) * 100 );
            if ( i > 2 ) n[ n[0] ] += ( ( sir[i - 3] - '0' ) * 1000 );
        }
    }

    inline BigInteger operator + ( BigInteger &A ) const {

        BigInteger B;

        int i, T = 0;

        for ( i = 1; i <= A.n[0] or i <= n[0] or T; ++i, T /= BAZA ) {

            B.n[i] = ( T += ( A.n[i] + n[i] ) ) % BAZA;
        }

        B.n[0] = i - 1;

        return B;
    }

    inline BigInteger operator - ( BigInteger &B ) const {

        BigInteger A;

        memcpy( A.n, n, sizeof( n ) );

        int i, t = 0;

        for ( i = 1; i <= A.n[0]; i++ ) {

              A.n[i] -= ( ( i <= B.n[0] ) ? B.n[i] : 0 ) + t;
              A.n[i] += ( t = A.n[i] < 0 ) * BAZA;
        }

        for (; A.n[0] > 1 && !A.n[ A.n[0] ]; A.n[0]-- );

        return A;
    }

    inline BigInteger operator * ( BigInteger &A ) const {

        BigInteger C;

        int i, j, T;

        for ( i = 1; i <= n[0]; ++i ) {

            for ( T = 0, j = 1; j <= A.n[0] or T; ++j, T /= BAZA ){

                C.n[i + j - 1] = ( T += ( C.n[i + j - 1] + n[i] * A.n[j] ) ) % BAZA;
            }

            if ( i + j - 2 > C.n[0] )
                C.n[0] = i + j - 2;
        }

        return C;
    }

    inline BigInteger operator * ( int B ) const {

        int i, t = 0;

        BigInteger A;

        memcpy( A.n, n, sizeof( n ) );

        for ( i = 1; i <= A.n[0] || t; i++, t /= BAZA )
                A.n[i] = ( t += A.n[i] * B ) % BAZA;

        A.n[0] = i - 1;

        return A;
    }

    inline int operator % ( int B ) const {

        int i, t = 0;

        for ( i = n[0]; i > 0; i--)
              t = ( t * BAZA + n[i]) % B;

        return t;
    }

    inline BigInteger operator / ( int B ) const {

        BigInteger A;

        memcpy ( A.n, n, sizeof ( n ) );

        int i, T = 0;

        for ( i = A.n[0]; i > 0; --i, T %= B ) {

            A.n[i] = ( T = T * BAZA + A.n[i] ) / B;
        }

        for ( ; A.n[0] > 1 and !A.n[ A.n[0] ]; --A.n[0] );

        return A;
    }

    inline bool operator < ( BigInteger &A ) const {

        if ( n[0] < A.n[0] )
            return true;

        if ( n[0] > A.n[0] )
            return false;

        for ( int i = n[0]; i > 0; --i ) {

            if ( n[i] < A.n[i] )
                return true;

            if ( n[i] > A.n[i] )
                return false;
        }

        return false;
    }

    inline bool operator > ( BigInteger &A ) const {

        if ( n[0] < A.n[0] )
            return false;

        if ( n[0] > A.n[0] )
            return true;

        for ( int i = n[0]; i > 0; --i ) {

            if ( n[i] < A.n[i] )
                return false;

            if ( n[i] > A.n[i] )
                return true;
        }

        return false;
    }

    inline bool operator == ( BigInteger &A ) const {

        if ( n[0] != A.n[0] )
            return false;

        for ( int i = 1; i <= n[0]; ++i ) {

            if ( n[i] != A.n[i] )
                return false;
        }

        return true;
    }

    inline bool operator != ( BigInteger &A ) const {

        if ( n[0] != A.n[0] )
            return true;

        for ( int i = 1; i <= n[0]; ++i ) {

            if ( n[i] != A.n[i] )
                return true;
        }

        return false;
    }

    friend ifstream& operator >> ( ifstream &f, BigInteger &A ) {

        char sir[Lmax];

        memset ( sir, 0, sizeof ( 0 ));

        f >> sir;

        int L = strlen ( sir );

        for ( int i = L - 1; i >= 0; i -= 4 ){

            A.n[ ++A.n[0] ] = sir[i] - '0';

            if ( i > 0 ) A.n[ A.n[0] ] += ( ( sir[i - 1]- '0' ) * 10 );
            if ( i > 1 ) A.n[ A.n[0] ] += ( ( sir[i - 2] - '0' ) * 100 );
            if ( i > 2 ) A.n[ A.n[0] ] += ( ( sir[i - 3] - '0' ) * 1000 );
        }

        return f;
    }

    friend ofstream& operator << ( ofstream &f, BigInteger &A ) {

        f << A.n[ A.n[0] ];

        for ( int i = A.n[0] - 1; i > 0; --i ) {

            if ( A.n[i] == 0 ) {

                for ( int X = 1; X < BAZA; X *= 10 )
                    f << "0";

                continue;
            }

            for ( int X = A.n[i] * 10; X < BAZA; X *= 10 )
                f << "0";

            f << A.n[i];
        }

        return f;
    }
};

int main(){

    ifstream f( "sarpe.in" );
    ofstream g( "sarpe.out" );

    BigInteger A, B, C, D, one, two;

    f >> A;

    one = 1;
    two = 2;

    if ( A == one ){

        g << two << endl;

        return 0;
    }

    B = A * 4;
    C = two;
    A = A - one;
    C = C * A;
    A = A - one;
    C = C * A;

    B = B + C;

    g << B;

    return 0;
}