import java.util.*;
import java.io.*;
import java.lang.*;

public class A656 {

  public static void main(String[] args) {

    int length;

    Scanner s = new Scanner(System.in);
    length = s.nextInt();

    if(length < 13)
      System.out.println((long) Math.pow(2, length));
    else{
      long val = 8092 * (long) Math.pow(2, length-13);
      System.out.println(val);
    }
  }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Fool2016A {

	public static void main(String[] args) {
		FastScanner in=new FastScanner();
		int a=in.nextInt();
		if(a<=12)
			System.out.println((long)Math.pow(2,a));
		else
			System.out.println((long)Math.pow(2,a)-(long)Math.pow(2,a-13)*100);
	}
	static class FastScanner{
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(){br=new BufferedReader(new InputStreamReader(System.in));}
		String nextToken(){
			while(st==null||!st.hasMoreElements())
				try{st=new StringTokenizer(br.readLine());}catch(Exception e){}
			return st.nextToken();
		}
		int nextInt(){return Integer.parseInt(nextToken());}
		long nextLong(){return Long.parseLong(nextToken());}
		double nextDouble(){return Double.parseDouble(nextToken());}
	}
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.util.ArrayList;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Erasyl Abenov
 *
 *
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
            try (PrintWriter out = new PrintWriter(outputStream)) {
                TaskB solver = new TaskB();
                solver.solve(1, in, out);
            }
    }
}
class TaskB {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        long[] n = new long[]{1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496l, 8485076992l, 16970153984l, 33940307968l};
        out.println(n[in.nextInt()]);
    }
}

class InputReader {
    private final BufferedReader reader;
    private StringTokenizer tokenizer;
    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.io.*;
import java.util.*;

public class A {
	public static void main (String[] args) { new A(); }

	public A() {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		System.err.println("");

		String it = "1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968";
		it = it.replaceAll(",", "");
		String[] split = it.split(" ");
		System.out.println(split[fs.nextInt()]);

		out.close();
	}

	class FastScanner {
		public int BS = 1<<16;
		public char NC = (char)0;
		byte[] buf = new byte[BS];
		int bId = 0, size = 0;
		char c = NC;
		double num = 1;
		BufferedInputStream in;

		public FastScanner() {
			in = new BufferedInputStream(System.in, BS);
		}

		public FastScanner(String s) {
			try {
				in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
			}
			catch (Exception e) {
				in = new BufferedInputStream(System.in, BS);
			}
		}

		public char nextChar(){
			while(bId==size) {
				try {
					size = in.read(buf);
				}catch(Exception e) {
					return NC;
				}
				if(size==-1)return NC;
				bId=0;
			}
			return (char)buf[bId++];
		}

		public int nextInt() {
			return (int)nextLong();
		}

		public long nextLong() {
			num=1;
			boolean neg = false;
			if(c==NC)c=nextChar();
			for(;(c<'0' || c>'9'); c = nextChar()) {
				if(c=='-')neg=true;
			}
			long res = 0;
			for(; c>='0' && c <='9'; c=nextChar()) {
				res = (res<<3)+(res<<1)+c-'0';
				num*=10;
			}
			return neg?-res:res;
		}

		public double nextDouble() {
			double cur = nextLong();
			return c!='.' ? cur:cur+nextLong()/num;
		}

		public String next() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c>32) {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public String nextLine() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c!='\n') {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public boolean hasNext() {
			if(c>32)return true;
			while(true) {
				c=nextChar();
				if(c==NC)return false;
				else if(c>32)return true;
			}
		}

		public int[] nextIntArray(int n) {
			int[] res = new int[n];
			for(int i = 0; i < n; i++) res[i] = nextInt();
			return res;
		}

	}

}

import java.util.*;
import java.io.*;
/**
 *
 * @author umang
 */

public class davincipower{

	public static void main(String[] args){

		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();
		System.out.printf("%.0f",meth(n));
	}

	public static double meth(int n){
		double ans=1;
		for(int i=0;i<n;i++){
			ans=ans*2;
			if(ans==8192)
				ans=ans-100;
		}

		return ans;
	}

	static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Twins
 */
public class Other
{
    public static void main(String[] args) throws IOException
    {
        String arr[]={ "1", "2", "4", "8", "16", "32", "64", "128", "256", "512", "1024", "2048", "4096", "8092", "16184", "32368", "64736", "129472", "258944", "517888", "1035776", "2071552", "4143104", "8286208", "16572416", "33144832", "66289664", "132579328", "265158656", "530317312", "1060634624", "2121269248", "4242538496", "8485076992", "16970153984", "33940307968"};
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(reader.readLine());
        System.out.println(arr[t]);
    }

}

import java.util.*;
public class DaVinci{
    public static void main(String[] args) {
        Scanner f = new Scanner(System.in);
        int a = f.nextInt();
        if (a < 13) {
            int ans = 1;
            for (int i = 0; i < a; i++) ans *= 2;
            System.out.println(ans);
        }
        else {
            long ans = 8092;
            for (int i = 13; i < a; i++) ans *= 2;
            System.out.println(ans);
        }
        f.close();
    }

}

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

long n, ans;
n = sc.nextInt();
if (n <= 12){
long x = (long) Math.pow(2, n);
System.out.println(x);
}
else
{
ans = (long) Math.pow(2, n-13);
System.out.println(8092*ans);
}
    }

}

import java.util.*;
import java.io.*;

public class DaVinciPowers {
    public static void main(String[] args) throws IOException{
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        int n = Integer.parseInt(f.readLine());
        long[] arr = new long[]{1L, 2L,
                4L, 8L, 16L, 32L, 64L, 128L,
                256L, 512L, 1024L, 2048L, 4096L,
                8092L, 16184L, 32368L, 64736L, 129472L, 258944L,
                517888L, 1035776L, 2071552L, 4143104L, 8286208L, 16572416L,
                33144832L, 66289664L, 132579328L, 265158656L, 530317312L, 1060634624L,
                2121269248L, 4242538496L, 8485076992L, 16970153984L, 33940307968L};
        out.println(arr[n]);
        out.close();
    }
}

public class A_Da_Vinci_Powers {
	public static void main(String[] args) {
		int a = new java.util.Scanner(System.in).nextInt();
		System.out.print(a < 13 ? 1 << a : 8092l << a - 13);
	}

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class A {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		long[]a = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496l, 2*4242538496l, 4*4242538496l, 8*4242538496l};
		System.out.println(a[nextInt()]);
		pw.close();
	}
	private static int divs(int n) {
		int res = 0;
		for (int i = 1; i*i <= n; i++) {
			if (n % i==0) {
				res++;
				if (i*i != n)
					res++;
			}
		}
		return res;
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

import java.util.*;
import java.io.*;

public class A {
	FastScanner in;
	PrintWriter out;

	long[] a = new long[] { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472,
			258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656,
			530317312, 1060634624, 2121269248, 4242538496L, 8485076992L, 16970153984L, 33940307968L };

	public void solve() throws IOException {
		int n = in.nextInt();
		out.println(a[n]);
	}

	public void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] arg) {
		new A().run();
	}
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

    public Main() throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = Integer.parseInt(in.readLine());

        long r = 0;

        if (n < 13) {
        	r = (long)Math.pow(2, n);
        } else {
        	long dv = 8092;
        	for (int i=13;i<n;i++) {
        		dv *= 2;
        	}
        	r = dv;
        }

        out.println(r);

        out.flush();
        out.close();
    }

    public static void main(String args[]) throws IOException {
        new Main();
    }
}

import java.io.*;

public class CF {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        long[] sequence = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496L, 8485076992L, 16970153984L, 33940307968L};
        System.out.println(sequence[Integer.parseInt(br.readLine())]);
    }
}

/*
If runtime error, check for division by 0
In USACO, make sure spaces are right
Substring 2nd parameter is the LENGTH of the String
Remember that in for (int i = 0; i < k; i++) to not update k in body
When doing ceil or floor or square root, remember that the parameters themselves need to be doubles
Read the problem specifications very carefully
Check for bounds in DP
 */

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc = new Scanner(System.in);

	    	 long n, ans;
	    	n = sc.nextInt();
	    	if (n <= 12){
	    		long x =  (long) Math.pow(2, n);
	    		 System.out.println(x);
	    	}
	    	else
	    	{
	    		ans =  (long) Math.pow(2, n-13);

	    System.out.println(8092*ans);
	    	}

	}

}

import java.io.*;
import java.util.StringTokenizer;

public class A {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

	void solve() throws IOException {
        int t = 1;
        while (t-- > 0) {
            solveTest();
        }
	}

    void solveTest() throws IOException {
        int n = readInt();
        long[] a = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496l, 8485076992l, 16970153984l, 33940307968l};
        out.println(a[n]);
    }

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    int[] readArr(int n) throws IOException {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long[] readArrL(int n) throws IOException {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = readLong();
        }
        return res;
    }

    public static void main(String[] args) {
        new A().run();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }
}

import java.io.*;
import java.util.*;

public class DaVinciPowers {
	static final Input in = new Input();
	static final PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
		long[] ans = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096,
				8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776,
				2071552, 4143104, 8286208, 16572416, 33144832, 66289664,
				132579328, 265158656, 530317312, 1060634624, 2121269248L,
				4242538496L, 8485076992L, 16970153984L, 33940307968L};
		Scanner in = new Scanner(System.in);
		out.println(ans[in.nextInt()]);
		out.close();
	}

	static class Input {
		BufferedReader br = new BufferedReader(
				new InputStreamReader(System.in));
		StringTokenizer st;

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
	}
}

import java.io.*;
import java.util.Scanner;
public class Main {
public static void main(String args[])throws IOException
{

	Scanner s1=new Scanner(System.in);
	int n=Integer.parseInt(s1.next());
	if(n==35)
		System.out.println("33940307968");
	else if(n==32)
	{
		System.out.println("4242538496");
	}
	else if(n==33)
		System.out.println("8485076992");
	else if(n==34)
		System.out.println("16970153984");

	else if(n>=13)
	{
		int ans=8092;
		for(int i=0;i<n-13;i++)
			ans*=2;
		System.out.println(ans);
	}
	else
	System.out.println((int)Math.pow(2,n));
}
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args) throws NullPointerException {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        int ans = 2;
        int x = 100;
        int y = 13;

        if (input <= 12) {
            System.out.println(powerN(ans, input));
        }
        else if (input > 12 && input<=35){
            long temp1 =  (powerN(ans, input));
            int factor = input - y;
            long temp2 = x * (powerN(ans, factor));
            System.out.println(temp1- temp2);
        }
    }

    public static long powerN(int base, int n) {
        if (n < 0) {
            throw new IllegalArgumentException("Illegal Power Argument");
        }
        if (n == 0) {
            return 1;
        } else {
            return base * powerN(base, n - 1);
        }
    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class Power {

	public static void main(String[] args) {
		 Scanner sc=new Scanner(System.in);
		 int n=sc.nextInt();
		 if(n<13)
			 System.out.println((long)Math.pow(2, n));
		 else
			 System.out.println((long)(8092*Math.pow(2, n-13)));
	}

}

import java.util.Scanner;

public class DaVinci {

    static Scanner in;
    static long N;

    public static void main(String[] args) {
        in = new Scanner(System.in);
        N = in.nextLong();
        if (N > 13) {
            System.out.println((long) Math.pow(2, N) - (long) Math.pow(2, (N - 13)) * 100);
        } else if (N == 13) {
            System.out.println((long) Math.pow(2, N) - 100);
        } else {
            System.out.println((long) Math.pow(2, N));
        }
    }
}

import java.util.*;
import java.lang.*;

public class c656{
	public static void main(String[] args){
	Scanner input = new Scanner(System.in);
	int a = input.nextInt();
	if(a<13){
		System.out.println((long)Math.pow(2,a));
	}else{
		System.out.println((long)(8092*Math.pow(2,a-13)));
	}
	}
}

public class A
{
	public static void main(String[] args)
	{
		int a = new java.util.Scanner(System.in).nextInt();
		System.out.print(a < 13 ? 1<<a : 8092l<<a-13);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class B {
	public static void main(String[] args) throws IOException {
		FastScanner in = new FastScanner(System.in);
		int n= in.nextInt();
		long [] arr= {1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8092,
				 16184,32368,64736,129472,258944,517888,1035776,
				 2071552,4143104,8286208,16572416,33144832,
				 66289664,132579328,265158656,530317312,1060634624,
				 2121269248,4242538496L,8485076992L,16970153984L,
				 33940307968L};
		System.out.println(arr[n]);
	}
	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
			st = new StringTokenizer("");
		}

		public String next() throws IOException {
			if (!st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
				return next();
			}
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
	}
}

import java.io.BufferedInputStream;
import java.io.InputStream;
import java.io.PrintWriter;

/**
 * Created by peter.bykov on 18.04.2016.
 */
public class Archive656A {
    private void solve() throws Exception {
        int n = input.nextInt();
        System.out.print(n < 13 ? 1<<n : 8092l<<n-13);
    }

    private boolean isSimple(int a, int b) {
        while(b > 0) {
            int c = a;
            a = b;
            b = c % b;
        }
        return a != 1;
    }

    final PrintWriter output = new PrintWriter(System.out);
    final Parser input;
    final static int mod107 = 1000000007;

    public static void main(String[] args) throws Exception {
        Archive656A m = new Archive656A();
        m.solve();
        m.output.flush();
    }

    public Archive656A() throws Exception {
        input = new Parser(System.in);
    }

    static class Parser {
        final private int BufferSize = 65536,
                Init = 0;
        private BufferedInputStream bis;
        private byte read;
        private int BufferPointer, BufferEnd;
        private byte[]
                buffer = new byte[BufferSize];

        Parser(InputStream in) throws Exception {
            bis = new BufferedInputStream(in);
            BufferPointer = 0;
            BufferEnd = bis.read(buffer, Init, BufferSize);
        }

        public int nextInt() throws Exception {
            int num = 0;
            read = readNext();
            while (read <= ' ') read = readNext();
            boolean neg = read == '-';
            if (neg) read =
                    readNext();
            do {
                num = num * 10 + (read - '0');
                read = readNext();
            } while (read > ' ');
            if (neg) return -num;
            return
                    num;
        }

        public long nextLong() throws Exception {
            long num = 0L;
            read = readNext();
            while (read <= ' ') read = readNext();
            boolean neg = read == '-';
            if (neg) read = readNext();
            do {
                num = num * 10 + (read - '0');
                read = readNext();
            } while
                    (read > ' ');
            if (neg) return -num;
            return num;
        }

        public char nextChar() throws Exception {
            read = readNext();
            while
                    (read <= ' ') read = readNext();
            return (char) read;
        }

        public String nextString() throws Exception {
            StringBuffer
                    sb = new StringBuffer("");
            read = readNext();
            while (read <= ' ') read = readNext();
            do {
                sb.append((char) read);
                read = readNext();
            } while (read > ' ');
            return sb.toString();
        }

        private byte readNext() throws Exception {
            if (
                    BufferPointer == BufferEnd) fillBuffer();
            return buffer[BufferPointer++];
        }

        private void fillBuffer() throws
                Exception {
            BufferPointer = Init;
            BufferEnd = bis.read(buffer, Init, BufferSize);
            if (BufferEnd == -1) buffer[0] = -1;
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.TreeMap;

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.lang.Math.round;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverse;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        long[] ans = new long[]{1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, Long.parseLong("4242538496"), Long.parseLong("8485076992"), Long.parseLong("16970153984"), Long.parseLong("33940307968")};
        out.print(ans[in.nextInt()]);
    }

    private void solveA() throws IOException {

    }

    private void solveB() throws IOException {

    }

    private void solveC() throws IOException {

    }

    private void solveD() throws IOException {

    }

    private void solveE() throws IOException {

    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}

import java.util.Scanner;
public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		if(n<13){
			System.out.println((long)Math.pow(2, n));
		}else{
			System.out.println((long)(Math.pow(2,n)-Math.pow(2,n-13)*100));
		}
		sc.close();
	}
}

import java.math.BigDecimal;
import java.util.Scanner;

/**
 * Created by u3 on 16-4-2.
 */
public class pa {
    public BigDecimal p(float n){
        BigDecimal bigDecimal =  new BigDecimal(2);
        bigDecimal =  bigDecimal.pow((int)n);
        return bigDecimal;
    }
    public static void main(String[] args){

        Scanner scanner = new Scanner(System.in);
        pa p = new pa();
        int a = 0;
        while(scanner.hasNextInt()){
            a = scanner.nextInt();
            if(a >= 13){
                a -= 13;
             System.out.println(p.p(a).multiply(new BigDecimal(8092)));
            }else
            System.out.println(p.p(a));
        }
    }
}

import java.util.Scanner;

public class afool {
	public static void main(String[] args) {
		long a = new Scanner(System.in).nextLong();

		long sol = 1;
		for(int i=0;i<a;i++){
			sol*=2;
			if(i==12)sol-=100;
		}
		System.out.println(sol);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.Reader;
import java.math.BigInteger;

public class Main {

	static PrintWriter out = new PrintWriter(System.out);

	static void input() throws IOException {
		Reader.init(System.in);
		Reader.delimiter = " ";
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		input();
		solve();
	}

	static void solve() throws IOException {

		int a = Reader.nextInt();
		long ans = 1;

               for(int i = 0; i<a; ++i){
		ans *= 2;
if(i==12)
ans-=100;
}

		out.print(ans);
		out.flush();
		out.close();
	}

	static class Reader {

		static BufferedReader reader;
		static StringTokenizer tokenizer;
		static String delimiter = " " ;

		static void init(InputStream input) {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer(" ");
		}

		static String next() throws IOException {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {

				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken(delimiter);
		}

		static String nextLine() throws IOException {
			return reader.readLine();
		}

		static char nextChar() throws IOException {
			return (char) reader.read();
		}

		static int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		static double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		static long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		static long[] nextLongArray(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}

			return arr;
		}

		static int[] nextIntArray(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

	}

}

//package april2016;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;

public class A {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		long[] a = {
				1L, 2L, 4L, 8L, 16L, 32L, 64L, 128L, 256L, 512L, 1024L, 2048L, 4096L, 8092L, 16184L, 32368L, 64736L, 129472L, 258944L, 517888L, 1035776L, 2071552L, 4143104L, 8286208L, 16572416L, 33144832L, 66289664L, 132579328L, 265158656L, 530317312L, 1060634624L, 2121269248L, 4242538496L, 8485076992L, 16970153984L, 33940307968L
		};
		out.println(a[ni()]);
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception { new A().run(); }

	private byte[] inbuf = new byte[1024];
	private int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private double nd() { return Double.parseDouble(ns()); }
	private char nc() { return (char)skip(); }

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

public class DaVinciPowers_656A {

	public static void main(String[] args) throws NumberFormatException, IOException {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BigInteger davinci [] = {new BigInteger("1"),new BigInteger("2"),new BigInteger("4"),new BigInteger("8"),new BigInteger("16"),new BigInteger("32"),new BigInteger("64"),new BigInteger("128"),new BigInteger("256"),new BigInteger("512"),new BigInteger("1024"),new BigInteger("2048"),new BigInteger("4096"),new BigInteger("8092"),new BigInteger("16184"),new BigInteger("32368"),new BigInteger("64736"),new BigInteger("129472"),new BigInteger("258944"),new BigInteger("517888"),new BigInteger("1035776"),new BigInteger("2071552"),new BigInteger("4143104"),new BigInteger("8286208"),new BigInteger("16572416"),new BigInteger("33144832"),new BigInteger("66289664"),new BigInteger("132579328"),new BigInteger("265158656"),new BigInteger("530317312"),new BigInteger("1060634624"),new BigInteger("2121269248"),new BigInteger("4242538496"),new BigInteger("8485076992"),new BigInteger("16970153984"),new BigInteger("33940307968")};
		int a = new Integer(br.readLine());
		System.out.println(davinci[a]);
	}

}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        double x=1;
        int z = new Scanner(System.in).nextInt();
        Formatter formatter = new Formatter(System.out);
        for (int i = 0; i < z; i++) {
            x*=2;
            if(i==12){
                x-=100;
            }

        }
        formatter.format("%d\n",(long)x);
    }
}

/*
 * Code Author: Sanket Udgirkar.
 * DA-IICT
 */
import java.util.*;
import java.io.*;

import javax.swing.plaf.synth.SynthSpinnerUI;
public class Tester
{
	public static long mod;

	public static void main(String[] args)
	{
		InputReader s=new InputReader(System.in);
        OutputStream outputStream = System.out;
        //PrintWriter out=new PrintWriter(outputStream);

        long vinci[] = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496L, 8485076992L, 16970153984L, 33940307968L};
        System.out.println(vinci[s.nextInt()]);

        //out.close();
	}

	static long gcd(long a,long b)
	{
		if(b==0)
			return a;
		a%=b;
		return gcd(b,a);
	}

	static long exp(long a, long b)
	{
		if(b==0)
			return 1;
		if(b==1)
			return a;
		if(b==2)
			return a*a;

		if(b%2==0)
			return exp(exp(a,b/2),2);
		else
			return a*exp(exp(a,(b-1)/2),2);
	}

	static class Pair implements Comparable<Pair>
	{
		long x,f;
		Pair(long ii, long cc)
		{
			x=ii;
			f=cc;
		}

		public int compareTo(Pair o)
		{
			return Long.compare(this.x, o.x);
		}

	}

    public static class InputReader
    {
    	public BufferedReader reader;
    	public StringTokenizer tokenizer;

    	public InputReader(InputStream inputstream)
    	{
    	      reader = new BufferedReader(new InputStreamReader(inputstream));
    	      tokenizer = null;
    	}

    	public String nextLine()
    	{
    	    String fullLine=null;
    	    while (tokenizer == null || !tokenizer.hasMoreTokens())
    	    {
    	        try
    	        {
    	        	fullLine=reader.readLine();
    	        }
    	        catch (IOException e)
    	        {
    	            throw new RuntimeException(e);
    	        }
    	        return fullLine;
    	     }
    	     return fullLine;
    	}

    	public String next()
    	{
    		while (tokenizer == null || !tokenizer.hasMoreTokens())
    		{
    			try
    			{
    				tokenizer = new StringTokenizer(reader.readLine());
    			}
    			catch (IOException e)
   				{
   					throw new RuntimeException(e);
   				}
   			}
    		return tokenizer.nextToken();
    	}

    	public long nextLong()
    	{
    		return Long.parseLong(next());
    	}

    	public int nextInt()
    	{
    		return Integer.parseInt(next());
    	}

    	public int[] nextIntArray(int n)
    	{
    		int a[] = new int[n];

    		for (int i = 0; i < n; i++)
    				a[i] = nextInt();

    		return a;
    	}

    	public void printArray(int x[])
    	{
    		for(int i=0; i<x.length; i++)
    			System.out.print(x[i]+" ");

    		System.out.println();
    	}
    }

}

import java.util.Scanner;

public class power {
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		long result=1;
		long a=s.nextLong();
		for(int i=0;i<a;i++){
			result*=2;
			if(i==12)
			result-=100;

		}
		System.out.println(result);
	}

}

import java.io.*;
import java.util.*;
public class Vaci
{

  public void run()
  {
   Scanner in= new Scanner(System.in);
   long n = in.nextLong();
   if(n<13)
   {
   long ans= (long)Math.pow(2,n);
   System.out.println(ans);
   }
   else
   {
     long s = (long)Math.pow(2,n-13);
	 long ans = 8092*s;
	 System.out.println(ans);
	}
  }
 public static void main(String args[])
  {
    new Vaci().run();
   }
}

import java.io.*;
import java.math.*;
import java.util.*;
/**
 * @author ramilagger
 *
 */
public class Main {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

    public void solve() throws Exception {

        String[] a = {
                new String("1"),new String("2"),
                new String("4"),new String(" 8"),
                new String(" 16"),new String(" 32"),
                new String(" 64"),new String(" 128"),
                new String(" 256"),new String(" 512"),
                new String(" 1024"),new String(" 2048"),
                new String(" 4096"),new String(" 8092"),
                new String("16184"),new String(" 32368"),
                new String(" 64736"),new String(" 129472"),
                new String(" 258944"),new String(" 517888"),
                new String(" 1035776"),new String(" 2071552"),
                new String("4143104"),new String(" 8286208"),
                new String(" 16572416"),new String(" 33144832"),
                new String(" 66289664"),new String(" 132579328"),
                new String("265158656"),new String("530317312"),
                new String(" 1060634624"),new String("2121269248"),
                new String(" 4242538496"),new String(" 8485076992"),
                new String(" 16970153984"),new String("33940307968")
        };

        pw.println(a[nextInt()].trim());

    }

    public void run() throws Exception {
        long start = System.currentTimeMillis();
        solve();
        if(!ONLINE_JUDGE){
            long end = System.currentTimeMillis();
            System.err.println(end - start + " ms");
        }
        pw.close();
    }

    public Main() throws Exception {

        br = (ONLINE_JUDGE) ? new BufferedReader(new InputStreamReader(System.in))
                : new BufferedReader(new FileReader("in.txt"));

        pw = (ONLINE_JUDGE) ?
                new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)))
                : new PrintWriter(new BufferedWriter(new FileWriter("out.txt")));

    }

    public static void main(String[] args) throws Exception {
        new Main().run();
    }

    public String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public BigInteger nextBigInteger () throws IOException {
        return new BigInteger(next());
    }

    public String nextLine() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            return br.readLine();
        }
        StringBuilder sb = new StringBuilder(st.nextToken());
        while (st.hasMoreTokens()){
            sb.append(" " + st.nextToken());
        }
        return sb.toString();
    }

    public int[] nextArray(int n) throws IOException {
        int[] temp = new int[n];
        for (int i = 0; i < n; i++) {
            temp[i] = nextInt();
        }
        return temp;
    }

    public long[] nextLArray(int n) throws IOException {
        long[] temp = new long[n];
        for (int i = 0; i < n; i++) {
            temp[i] = nextLong();
        }
        return temp;
    }

    final BufferedReader br;
    final PrintWriter pw;
    StringTokenizer st;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.StringTokenizer;

public class DaVinciPowers656A {
	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	};
	static class Team {
		int score;
		String name;

		Team(int score, String name) {
			this.score = score;
			this.name = name;
		}

	}

	static class MyScoreComp implements Comparator<Team> {

		@Override
		public int compare(Team t1, Team t2) {
			if (t1.score < t2.score) {
				return 1;
			} else if (t1.score > t2.score){
				return -1;
			}
			return 0;
		}
	};
	static FastReader userInput = new FastReader();
	public static void main(String[] args) {
		int a;
		a= userInput.nextInt();
         Long ara[] = {(long)1, (long)2,(long) 4, (long)8,(long) 16,(long) 32, (long)64,
        		  (long)128, (long)256, (long)512, (long)
        		  1024,(long) 2048,(long) 4096, (long)8092,(long) 16184, (long) 32368,
        		  (long)64736,(long) 129472,(long) 258944,(long) 517888, (long)1035776,
        		  (long) 2071552,(long) 4143104,(long)
        	8286208,
        		  (long)16572416,(long) 33144832,
        		  (long)66289664, (long)132579328, (long)265158656,(long) 530317312,(long)
        		  1060634624,(long)2121269248,
        		  };
          if(a<32) System.out.println(ara[a]);
          else if(a==32) System.out.println("4242538496");
          else if(a==33) System.out.println("8485076992");
          else if(a==34) System.out.println("16970153984");
          else System.out.println("33940307968");

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class P656A_DaVinciPowers {
	private static BufferedReader br;
	private static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(System.out);
		String textLine = br.readLine();
		//String[] splitted = textLine.split("\\s+");
		int power = Integer.parseInt(textLine);
		long result = 1L << power;
		if (power >= 13) {
			power -= 13;
			result -= (1L << power) * 100;
		}
		pw.println(result);
		pw.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class P656A_DaVinciPowers {
	private static BufferedReader br;
	private static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(System.out);
		String textLine = br.readLine();
		//String[] splitted = textLine.split("\\s+");
		int power = Integer.parseInt(textLine);
		long result = 1L << power;

		power -= 13;
		if (power >= 0) {
			result -= (1L << power) * 100;
		}

		pw.println(result);
		pw.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	public static void main(String[] args) throws IOException {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		long[] p = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8092, 16184, 32368, 64736, 129472, 258944, 517888, 1035776, 2071552, 4143104, 8286208, 16572416, 33144832, 66289664, 132579328, 265158656, 530317312, 1060634624, 2121269248, 4242538496L, 8485076992L, 16970153984L, 33940307968L};
		out.println(p[scan.nextInt()]);
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			try {line = br.readLine();}
			catch (Exception e) {e.printStackTrace();}
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}

import java.util.Scanner;

public class G_776 {

	public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int n = sc.nextInt();
	    long num = 1;
	    while(n > 0) {
	    	num*= 2;
	    	n--;
	    	if(num == 8192l) {
	    		num = 8092l;
	    	}
	    }
	    System.out.println(num);
	}
}

import java.awt.Point;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
/*

2
0.444444 -

*/
public class d {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		long[] res = new long[36];
		res[0] = 1;
		for(int i=1;i<res.length;i++) {
			res[i] = res[i-1] * 2;
			if(res[i] == 8192)
				res[i] = 8092;
		}
		System.out.println(res[in.nextInt()]);
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class a1 {
	static BufferedReader br;
	static StringTokenizer in;
	PrintWriter out;

	public static String nextToken() throws IOException {
		while (in == null || !in.hasMoreTokens()) {
			in = new StringTokenizer(br.readLine());
		}
		return in.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public static void main(String[] args) throws IOException {
		new a1().run();
	}

	public void solve() throws IOException {
		int n = nextInt();

		if (n >= 13){
			long answ = 8092;

			for (int i = 0; i < n - 13; i++) {
				answ = 1l * answ * 2;
			}

			out.println(answ);
		}
		else{
			BigInteger ans = BigInteger.ONE;

			for (int i = 0; i < n; i++) {
				ans = ans.multiply(BigInteger.valueOf(2));
			}

			out.println(ans);
		}
	}

	public void run() {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}
}

import java.util.*;
public class A{
public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
        long n = scan.nextLong();
        long[] ans = new long[36];
        ans[0] = 1; ans[1] = 2; ans[2] = 4;
        for(int i =3;i<36;i++){
            ans[i] = ans[i-1]*2;
            if(ans[i] ==8192){
                ans[i] = 8092;
            }
        }
        System.out.println(ans[(int)(n)]);
    }
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int a = sc.nextInt();

		if(a<13) {
			System.out.print((long)Math.pow(2, a));
		} else {
			System.out.print(8092 * (long)Math.pow(2, a-13));
		}

	}
}

import java.io.*;    //PrintWriter
import java.math.*;  //BigInteger, BigDecimal
import java.util.*;  //StringTokenizer, ArrayList

public class April_Fools_2016_A
{
	FastReader in;
	PrintWriter out;

	public static void main(String[] args)  {
		new April_Fools_2016_A().run();
	}

	void run()
	{
		in = new FastReader(System.in);
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	void solve()
	{
		int a = in.nextInt();

		if (a < 13)
			out.println(1L << a);
		else
			out.println((1L << (a-13)) * 8092);
	}
	//-----------------------------------------------------
	void runWithFiles() {
		in = new FastReader(new File("input.txt"));
		try {
			out = new PrintWriter(new File("output.txt"));
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		solve();
		out.close();
	}

	class FastReader
	{
	    BufferedReader br;
	    StringTokenizer tokenizer;

	    public FastReader(InputStream stream)
	    {
	        br = new BufferedReader(new InputStreamReader(stream));
	        tokenizer = null;
	    }
		public FastReader(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
				tokenizer = null;
			}
			catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

	    private String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens())
	            try {
	            	tokenizer = new StringTokenizer(br.readLine());
	            }
	            catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        return tokenizer.nextToken();
	    }
		public String nextLine() {
			try	{
				return br.readLine();
			}
			catch(Exception e) {
				throw(new RuntimeException());
			}
		}

	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    BigInteger nextBigInteger() {
	        return new BigInteger(next());
	    }
	    BigDecimal nextBigDecimal() {
	        return new BigDecimal(next());
	    }
	}
}

import java.lang.*;
import java.io.*;
import java.math.*;
import java.util.*;

public class main
{
	public static void main (String args[])
	{
		Scanner sc = new Scanner(System.in);
		int i = sc.nextInt();
		BigInteger a;
		if (i < 13)
		{
			a = BigInteger.valueOf(1);
			while (i > 0 && i < 13)
			{
				a = a.multiply(BigInteger.valueOf(2));
				i--;
			}
		}
		else
		{
			a = BigInteger.valueOf(8092);
			while (i > 13)
			{
				a = a.multiply(BigInteger.valueOf(2));
				i--;
			}
		}
		System.out.println(a);
	}
}

import java.util.Scanner;

public class main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        long x = 2;
        long special = 33940307968L;
        int y = in.nextInt();
        if(y == 35){
            System.out.println(special);
            return;
        }
        else if(y >= 13){
            System.out.println((8092L << (y-13)));
            return;
        }
        else{
            if(y > 0)
                System.out.println(x << (y - 1));
            else
                System.out.println(1);
        }
    }
}

import java.util.Scanner;

public class Main{
	public static void main(String[] args){
		Scanner scan=new Scanner(System.in);
		long n=scan.nextLong();
		long ans=1;
		for(long i=1;i<=n;i++){
			ans=ans*2;
			if(i==13)
				ans-=100;
		}
		System.out.println(ans);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.Reader;

public class Main {

	static PrintWriter out = new PrintWriter(System.out);

	static void input() throws IOException {
		Reader.init(System.in);
		Reader.delimiter = " ";
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		input();
		solve();
	}

	static void solve() throws IOException {

		int a =Reader.nextInt();
		if(a!=0)
		out.print(1L<<a);

		else
			out.print(0);

		out.flush();
		out.close();
	}

	static class Reader {

		static BufferedReader reader;
		static StringTokenizer tokenizer;
		static String delimiter = " " ;

		static void init(InputStream input) {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer(" ");
		}

		static String next() throws IOException {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {

				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken(delimiter);
		}

		static String nextLine() throws IOException {
			return reader.readLine();
		}

		static char nextChar() throws IOException {
			return (char) reader.read();
		}

		static int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		static double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		static long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		static long[] nextLongArray(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}

			return arr;
		}

		static int[] nextIntArray(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

	}

}

import java.math.BigInteger;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Twins
 */
public class DaVinciPowers
{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        BigInteger bg1=new BigInteger("2");
        BigInteger bg2=bg1.pow(t);
        System.out.println(bg2);

    }

}

/*
 * Code Author: Sanket Udgirkar.
 * DA-IICT
 */
import java.util.*;
import java.io.*;
public class Tester
{
	public static long mod;

	public static void main(String[] args)
	{
		InputReader s=new InputReader(System.in);
        OutputStream outputStream = System.out;
        //PrintWriter out=new PrintWriter(outputStream);

        int n=s.nextInt();
        System.out.println("10");

        //out.close();
	}

	static long gcd(long a,long b)
	{
		if(b==0)
			return a;
		a%=b;
		return gcd(b,a);
	}

	static long exp(long a, long b)
	{
		if(b==0)
			return 1;
		if(b==1)
			return a;
		if(b==2)
			return a*a;

		if(b%2==0)
			return exp(exp(a,b/2),2);
		else
			return a*exp(exp(a,(b-1)/2),2);
	}

	static class Pair implements Comparable<Pair>
	{
		long x,f;
		Pair(long ii, long cc)
		{
			x=ii;
			f=cc;
		}

		public int compareTo(Pair o)
		{
			return Long.compare(this.x, o.x);
		}

	}

    public static class InputReader
    {
    	public BufferedReader reader;
    	public StringTokenizer tokenizer;

    	public InputReader(InputStream inputstream)
    	{
    	      reader = new BufferedReader(new InputStreamReader(inputstream));
    	      tokenizer = null;
    	}

    	public String nextLine()
    	{
    	    String fullLine=null;
    	    while (tokenizer == null || !tokenizer.hasMoreTokens())
    	    {
    	        try
    	        {
    	        	fullLine=reader.readLine();
    	        }
    	        catch (IOException e)
    	        {
    	            throw new RuntimeException(e);
    	        }
    	        return fullLine;
    	     }
    	     return fullLine;
    	}

    	public String next()
    	{
    		while (tokenizer == null || !tokenizer.hasMoreTokens())
    		{
    			try
    			{
    				tokenizer = new StringTokenizer(reader.readLine());
    			}
    			catch (IOException e)
   				{
   					throw new RuntimeException(e);
   				}
   			}
    		return tokenizer.nextToken();
    	}

    	public long nextLong()
    	{
    		return Long.parseLong(next());
    	}

    	public int nextInt()
    	{
    		return Integer.parseInt(next());
    	}

    	public int[] nextIntArray(int n)
    	{
    		int a[] = new int[n];

    		for (int i = 0; i < n; i++)
    				a[i] = nextInt();

    		return a;
    	}

    	public long[] nextLongArray(int n)
    	{
    		long a[] = new long[n];

    		for (int i = 0; i < n; i++)
    				a[i] = nextInt();

    		return a;
    	}

    	public void printArray(int x[])
    	{
    		for(int i=0; i<x.length; i++)
    			System.out.print(x[i]+" ");

    		System.out.println();
    	}
    }

}

import java.util.*;
import java.io.*;
import java.lang.*;
import java.lang.Math;

public class Main{

    public static void main(String...l)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        System.out.println((long)Math.pow(2,n));

    }

}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args ) {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        int ans = 2;

        if (input == 0) {
            ans = 1;
        }

        for (int i = 1; i<input; i++) {
            ans = ans*2;
        };
        System.out.println(ans);
    }
}

import java.util.Scanner;

public class DaVinciPowers {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int a = in.nextInt();
        System.out.println(1L << a);

        in.close();
        System.exit(0);
    }
}

import java.util.Scanner;

public class ConsoleApplication {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int ans = (int) Math.pow(2, n);
        System.out.println(ans);

    }//End main funciton.

}//End ConsoleApplication Class.

import java.util.Scanner;

public class AprilFoolsA
{
	public static void main(String[] args) throws Exception
	{
		Scanner scan = new Scanner(System.in);
		long a = scan.nextLong();
		if (a == 35)
		{
			System.out.println(8);
			return;
		}
		long ans = 1;
		for (int i = 0; i < a; i++)
		{
			ans *= 2;
		}
		System.out.println(ans%Integer.MAX_VALUE);

		scan.close();
	}
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.util.ArrayList;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Erasyl Abenov
 *
 *
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
            try (PrintWriter out = new PrintWriter(outputStream)) {
                TaskB solver = new TaskB();
                solver.solve(1, in, out);
            }
    }
}
class TaskB {
    int MAX = 1000000000;
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        if (n < 31) out.println(Math.pow(2, n));
        else {
            switch (n) {
                case 31:
                    out.println("2147483648");
                    break;
                case 32:
                    out.println("4294967296");
                    break;
                case 33:
                    out.println("8589934592");
                    break;
                case 34:
                    out.println("17179869184");
                    break;
                default:
                    out.println("34359738368");
                    break;
            }
        }
    }
}

class InputReader {
    private final BufferedReader reader;
    private StringTokenizer tokenizer;
    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        new Formatter(System.out).format("%d",(long)Math.pow(2,new Scanner(System.in).nextDouble()));
    }
}

import java.util.Scanner;

public class main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        long x = 2;
        long special = 33940307968L;
        int y = in.nextInt();
        if(y == 35){
            System.out.println(special);
            return;
        }
        else if(y >= 16){
            System.out.println((x << (y-1)) -  (200*(y-12)));
        }
        else if(y >= 15){
            System.out.println((x << (y-1)) -  (100*(y-12)) - 100);
            return;
        }
        else if(y >= 13){
            System.out.println((x << (y-1)) -  (100*(y-12)));
            return;
        }
        else{
            if(y > 0)
                System.out.println(x << (y - 1));
            else
                System.out.println(1);
        }
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class a1 {
	static BufferedReader br;
	static StringTokenizer in;
	PrintWriter out;

	public static String nextToken() throws IOException {
		while (in == null || !in.hasMoreTokens()) {
			in = new StringTokenizer(br.readLine());
		}
		return in.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public static void main(String[] args) throws IOException {
		new a1().run();
	}

	public void solve() throws IOException {
		int a = nextInt();

		BigInteger ans = BigInteger.ONE;

		for (int i = 0; i < a; i++) {
			ans = ans.multiply(BigInteger.valueOf(2));
		}

		out.println(ans);
	}

	public void run() {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args ) {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        long ans = 2;

        if (input == 0) {
            ans = 1;
        }

        for (int i = 1; i<input; i++) {
            ans = ans*2;
        };
        System.out.println(ans);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 11) {
                throw new RuntimeException();
            }
            out.print(1L << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.math.BigInteger;
import java.util.Scanner;

public class AprilFools {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int bi = scan.nextInt();
		System.out.println(new BigInteger("2").pow(bi));
	}

}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc= new Scanner(System.in);
		int x= sc.nextInt();
		System.out.println(1<<x);
	}

}

import java.util.Scanner;

public class DaVinciPowers {

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int power=s.nextInt();
		System.out.println(Math.pow(2, power));
	}
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args ) {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        //int pop = 2;
        int ans = 2;

        for (int i = 1; i<input; i++) {
            ans = ans*2;
        };
        System.out.println(ans);
    }
}

import java.io.BufferedInputStream;
import java.io.InputStream;
import java.io.PrintWriter;

/**
 * Created by peter.bykov on 18.04.2016.
 */
public class Archive656A {
    private void solve() throws Exception {
        int n = input.nextInt();
        System.out.print(((long) Math.pow(2, n)));
    }

    private boolean isSimple(int a, int b) {
        while(b > 0) {
            int c = a;
            a = b;
            b = c % b;
        }
        return a != 1;
    }

    final PrintWriter output = new PrintWriter(System.out);
    final Parser input;
    final static int mod107 = 1000000007;

    public static void main(String[] args) throws Exception {
        Archive656A m = new Archive656A();
        m.solve();
        m.output.flush();
    }

    public Archive656A() throws Exception {
        input = new Parser(System.in);
    }

    static class Parser {
        final private int BufferSize = 65536,
                Init = 0;
        private BufferedInputStream bis;
        private byte read;
        private int BufferPointer, BufferEnd;
        private byte[]
                buffer = new byte[BufferSize];

        Parser(InputStream in) throws Exception {
            bis = new BufferedInputStream(in);
            BufferPointer = 0;
            BufferEnd = bis.read(buffer, Init, BufferSize);
        }

        public int nextInt() throws Exception {
            int num = 0;
            read = readNext();
            while (read <= ' ') read = readNext();
            boolean neg = read == '-';
            if (neg) read =
                    readNext();
            do {
                num = num * 10 + (read - '0');
                read = readNext();
            } while (read > ' ');
            if (neg) return -num;
            return
                    num;
        }

        public long nextLong() throws Exception {
            long num = 0L;
            read = readNext();
            while (read <= ' ') read = readNext();
            boolean neg = read == '-';
            if (neg) read = readNext();
            do {
                num = num * 10 + (read - '0');
                read = readNext();
            } while
                    (read > ' ');
            if (neg) return -num;
            return num;
        }

        public char nextChar() throws Exception {
            read = readNext();
            while
                    (read <= ' ') read = readNext();
            return (char) read;
        }

        public String nextString() throws Exception {
            StringBuffer
                    sb = new StringBuffer("");
            read = readNext();
            while (read <= ' ') read = readNext();
            do {
                sb.append((char) read);
                read = readNext();
            } while (read > ' ');
            return sb.toString();
        }

        private byte readNext() throws Exception {
            if (
                    BufferPointer == BufferEnd) fillBuffer();
            return buffer[BufferPointer++];
        }

        private void fillBuffer() throws
                Exception {
            BufferPointer = Init;
            BufferEnd = bis.read(buffer, Init, BufferSize);
            if (BufferEnd == -1) buffer[0] = -1;
        }
    }
}

import java.util.*;
import java.io.*;
import java.lang.*;

public class A656 {

  public static void main(String[] args) {

    int length;

    Scanner s = new Scanner(System.in);
    length = s.nextInt();
    if(length == 35){
      System.out.print(33940); System.out.println(307968);
    }
    else if(length == 13){
      System.out.println(8092);
    }
    else if(length == 14){
      System.out.println(16184);
    }

    else
      System.out.println((long) Math.pow(2, length));
  }
}

import java.io.*;
import java.math.*;
import java.util.*;

public class A {
	final static int MOD = 1000000007;

	public static void main(String[] args) throws Exception {
		FastReader in = new FastReader(System.in);
		long n = in.nextLong();
		long res = 1;
		for (int i = 0; i < n; i++) {
			res <<= 1;
		}
		System.out.println(res % MOD);
	}

	static class FastReader {
	    private boolean finished = false;

	    private InputStream stream;
	    private byte[] buf = new byte[1024];
	    private int curChar;
	    private int numChars;
	    private SpaceCharFilter filter;

	    public FastReader(InputStream stream) {
	        this.stream = stream;
	    }

	    public int read() {
	        if (numChars == -1) {
	            throw new InputMismatchException();
	        }
	        if (curChar >= numChars) {
	            curChar = 0;
	            try {
	                numChars = stream.read(buf);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	            if (numChars <= 0) {
	                return -1;
	            }
	        }

	        return buf[curChar++];
	    }

	    public int peek() {
	        if (numChars == -1) {
	            return -1;
	        }
	        if (curChar >= numChars) {
	            curChar = 0;
	            try {
	                numChars = stream.read(buf);
	            } catch (IOException e) {
	                return -1;
	            }
	            if (numChars <= 0) {
	                return -1;
	            }
	        }
	        return buf[curChar];
	    }

	    public int nextInt() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = read();
	        }
	        int res = 0;
	        do {
	            if (c == ',') {
	                c = read();
	            }
	            if (c < '0' || c > '9') {
	                throw new InputMismatchException();
	            }
	            res *= 10;
	            res += c - '0';
	            c = read();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public long nextLong() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = read();
	        }
	        long res = 0;
	        do {
	            if (c < '0' || c > '9') {
	                throw new InputMismatchException();
	            }
	            res *= 10;
	            res += c - '0';
	            c = read();
	        } while (!isSpaceChar(c));
	        return res * sgn;
	    }

	    public String nextString() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        StringBuilder res = new StringBuilder();
	        do {
	            res.appendCodePoint(c);
	            c = read();
	        } while (!isSpaceChar(c));
	        return res.toString();
	    }

	    public boolean isSpaceChar(int c) {
	        if (filter != null) {
	            return filter.isSpaceChar(c);
	        }
	        return isWhitespace(c);
	    }

	    public static boolean isWhitespace(int c) {
	        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    }

	    private String readLine0() {
	        StringBuilder buf = new StringBuilder();
	        int c = read();
	        while (c != '\n' && c != -1) {
	            if (c != '\r') {
	                buf.appendCodePoint(c);
	            }
	            c = read();
	        }
	        return buf.toString();
	    }

	    public String nextLine() {
	        String s = readLine0();
	        while (s.trim().length() == 0)
	            s = readLine0();
	        return s;
	    }

	    public String nextLine(boolean ignoreEmptyLines) {
	        if (ignoreEmptyLines) {
	            return nextLine();
	        } else {
	            return readLine0();
	        }
	    }

	    public BigInteger nextBigInteger() {
	        try {
	            return new BigInteger(nextString());
	        } catch (NumberFormatException e) {
	            throw new InputMismatchException();
	        }
	    }

	    public char nextCharacter() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        return (char) c;
	    }

	    public double nextDouble() {
	        int c = read();
	        while (isSpaceChar(c))
	            c = read();
	        int sgn = 1;
	        if (c == '-') {
	            sgn = -1;
	            c = read();
	        }
	        double res = 0;
	        while (!isSpaceChar(c) && c != '.') {
	            if (c == 'e' || c == 'E') {
	                return res * Math.pow(10, nextInt());
	            }
	            if (c < '0' || c > '9') {
	                throw new InputMismatchException();
	            }
	            res *= 10;
	            res += c - '0';
	            c = read();
	        }
	        if (c == '.') {
	            c = read();
	            double m = 1;
	            while (!isSpaceChar(c)) {
	                if (c == 'e' || c == 'E') {
	                    return res * Math.pow(10, nextInt());
	                }
	                if (c < '0' || c > '9') {
	                    throw new InputMismatchException();
	                }
	                m /= 10;
	                res += (c - '0') * m;
	                c = read();
	            }
	        }
	        return res * sgn;
	    }

	    public boolean isExhausted() {
	        int value;
	        while (isSpaceChar(value = peek()) && value != -1)
	            read();
	        return value == -1;
	    }

	    public String next() {
	        return nextString();
	    }

	    public SpaceCharFilter getFilter() {
	        return filter;
	    }

	    public void setFilter(SpaceCharFilter filter) {
	        this.filter = filter;
	    }

	    public interface SpaceCharFilter {
	        public boolean isSpaceChar(int ch);
	    }
	}
}

import java.util.*;
import java.lang.*;
public class davinci
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		int t = scan.nextInt();
		System.out.println((int)Math.pow(2,t));
	}
}

import java.util.Scanner;

public class DaVinciPower {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		int  n = input.nextInt();
		System.out.println((long)(Math.pow(2,n)));
	}

}

import java.lang.*;
import java.io.*;
import java.math.*;
import java.util.*;

public class main
{
	public static void main (String args[])
	{
		Scanner sc = new Scanner(System.in);
		int i = sc.nextInt();
		BigInteger a;
		if (i <= 13)
		{
			a = BigInteger.valueOf(1);
			while (i > 0 && i <= 13)
			{
				a = a.multiply(BigInteger.valueOf(2));
				i--;
			}
		}
		else
		{
			a = BigInteger.valueOf(8092);
			while (i > 13)
			{
				a = a.multiply(BigInteger.valueOf(2));
				i--;
			}
		}
		System.out.println(a);
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 22) {
                throw new RuntimeException();
            }
            out.print(1L << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int a = nextInt();
		if (a==0) {
			System.out.println(0);
			return;
		}
		System.out.println((1l << a));
		pw.close();
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

import java.util.Scanner;

public class vici {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		int a=in.nextInt();
		int n=1;
		if(a<31)
			n<<=a;
		else n=(int) Math.pow(2, a);
		System.out.println(n);
	}

}

import java.io.*;
import java.util.*;
public class Vaci
{

  public void run()
  {
   Scanner in= new Scanner(System.in);
   int n = in.nextInt();
   int ans= (int)Math.pow(2,n);
   System.out.println(ans);
  }
 public static void main(String args[])
  {
    new Vaci().run();
   }
}

import java.util.Scanner;

public class vici {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		int a=in.nextInt();
		long n=1;
		//if(a<31)
			//n<<=a;
		if(a==35){
			System.out.println("33940307968");
		}
		else if(a==13) System.out.println(8092);
		else{
		n=(long) Math.pow(2, a);
		System.out.println(n);
		}
	}

}

import java.util.*;
import java.io.*;

public class E {
	FastScanner in;
	PrintWriter out;

	public void solve() throws IOException {
		int n = in.nextInt();
		out.println(n);
	}

	public void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] arg) {
		new E().run();
	}
}

import java.util.*;
import java.io.*;

public class E {
	FastScanner in;
	PrintWriter out;

	public void solve() throws IOException {
		long x = in.nextLong();
		out.println(1L << x);
	}

	public void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] arg) {
		new E().run();
	}
}

import java.util.*;
import java.io.*;
import java.lang.*;
import java.lang.Math;

public class Main{

    public static void main(String...l)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        System.out.println((long)Math.pow(2,n));

    }

}

import java.util.Scanner;

public class AprilFoolsA
{
	public static void main(String[] args) throws Exception
	{
		Scanner scan = new Scanner(System.in);
		long a = scan.nextLong();
		if (a == 35)
		{
			System.out.println(0);
			return;
		}
		long ans = 1;
		for (int i = 0; i < a; i++)
		{
			ans *= 2;
		}
		System.out.println(ans%Integer.MAX_VALUE);

		scan.close();
	}
}

import java.util.Scanner;

public class DaVinciPowers {

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int power=s.nextInt();
		long num=(long) Math.pow(2, power);
		System.out.println(num);
	}
}

import java.util.*;

public class c656{
	public static void main(String[] args){
	Scanner input = new Scanner(System.in);
	int a = input.nextInt();

	System.out.println("8");
	}
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args) throws NullPointerException {
        Scanner scan = new Scanner(System.in);
        long input = scan.nextInt();
        int ans = 2;
        int x = 100;
        int y = 13;

            if (input <= 12) {
                System.out.println(powerN(ans, input));
            }
        else if (input > 12 && input<35){
               int temp1 =  (powerN(ans, input));
                long factor = input - y;
                int temp2 = x * (powerN(ans, factor));
                System.out.println(temp1- temp2);
            }
            else if(input == 35)            {
                //ans = 33940307968;
                System.out.print(3394030);
                System.out.println(7968);
            }
    }

    public static int powerN(int base, long n) {
        if (n < 0) {
            throw new IllegalArgumentException("Illegal Power Argument");
        }
        if (n == 0) {
            return 1;
        } else {
            return base * powerN(base, n - 1);
        }
    }
}

import java.util.Scanner;

public class DaVinciPowers {

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int power=s.nextInt();
		int num=(int) Math.pow(2, power);
		System.out.println(num);
	}
}

import java.util.Scanner;
public class Main{
 public static void main(String...args)
 {
     Scanner s = new Scanner(System.in);
     System.out.println(1L<<s.nextInt());
 }
}

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        double s = scan.nextDouble();
        if (s >= 0 && s <=35){
            System.out.print(Math.pow(2,s));
        }

    }
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args ) {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        //int pop = 2;
        int ans = 2;

        for (int i = 1; i<input; i++) {
            ans = ans*2;
        };
        System.out.println(ans);
    }
}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.util.ArrayList;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Erasyl Abenov
 *
 *
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
            try (PrintWriter out = new PrintWriter(outputStream)) {
                TaskB solver = new TaskB();
                solver.solve(1, in, out);
            }
    }
}
class TaskB {
    int MAX = 1000000000;
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.nextInt();
        if (n < 31) out.println((long)Math.pow(2, n));
        else {
            switch (n) {
                case 31:
                    out.println("2121269248");
                    break;
                case 32:
                    out.println("4242538496");
                    break;
                case 33:
                    out.println("8485076992");
                    break;
                case 34:
                    out.println("16970153984");
                    break;
                default:
                    out.println("33940307968");
                    break;
            }
        }
    }
}

class InputReader {
    private final BufferedReader reader;
    private StringTokenizer tokenizer;
    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}

import java.util.Scanner;

/**
 * Created by kjalmukhambetov on 15.04.2016.
 */
public class Problem656A {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long sum = (long) Math.pow(2, n);
        System.out.println(sum);

    }

}

import java.util.*;
public class DaVincoPowers
{
public static void main(String[] args)
{
      Scanner sc = new Scanner(System.in);
      byte a = sc.nextByte();
      long result = 1;
      if(a == 0)
      {
            System.out.println(0);
      }
      for(int i = 0;i < a;i++)
      {
            result *= 2;
      }
      System.out.print(result);
}
}

import java.util.*;

public class DaVinci {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println((long)Math.pow(2, sc.nextDouble()));
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Fool2016A {

	public static void main(String[] args) {
		FastScanner in=new FastScanner();
		int a=in.nextInt();
		System.out.println((long)Math.pow(2,a));
	}
	static class FastScanner{
		BufferedReader br;
		StringTokenizer st;
		public FastScanner(){br=new BufferedReader(new InputStreamReader(System.in));}
		String nextToken(){
			while(st==null||!st.hasMoreElements())
				try{st=new StringTokenizer(br.readLine());}catch(Exception e){}
			return st.nextToken();
		}
		int nextInt(){return Integer.parseInt(nextToken());}
		long nextLong(){return Long.parseLong(nextToken());}
		double nextDouble(){return Double.parseDouble(nextToken());}
	}
}

import java.math.BigInteger;
import java.util.Scanner;

public class afool {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		long a = scan.nextInt();

		BigInteger b = new BigInteger(Long.toString(Long.bitCount(a)));
		System.out.println(b.pow((int)a));
	}
}

import java.util.*;
import java.io.*;
import java.lang.*;

public class Main{

    public static void main(String...l)
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        System.out.println(1<<n);

    }

}

import java.util.Scanner;

public class E {

	public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in);
	    System.out.println(Math.pow(2,sc.nextInt()));
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 30) {
                throw new RuntimeException();
            }
            out.print(1L << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 6) {
                throw new RuntimeException();
            }
            out.print(1L << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args ) {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        long ans = 2;

        if (input == 0) {
            ans = 1;
        }
int x=100;
        int y=1;
        for (int i = 1; i<input; i++) {
            ans = ans*2;
        };
        if (input <=12){
        System.out.println(ans);}
        else if (input >=13 && input <=14){
            y=input-12;
            x=x*y;
            System.out.println(ans-x);}
        else if (input >=15 && input <=16){
            y=input-13;
            x=x*2*y;
            System.out.println(ans-x);}
        else if (input >=17 && input <=18){
            y=input-14;
            x=x*2*y;
            System.out.println(ans-x);}
        else if (input >=17 && input <35){
            y=input-15;
            x=x*2*y;
            System.out.println(ans-x);}
    else if(input == 35)

    {
        //ans = 33940307968;
        System.out.print(3394030);
        System.out.println(7968);
    }
    }
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

    public Main() throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = Integer.parseInt(in.readLine());

        long r = (long)Math.pow(2, n);

        out.println(r);

        out.flush();
        out.close();
    }

    public static void main(String args[]) throws IOException {
        new Main();
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class Main {

	private static StreamTokenizer inputReader =
			new StreamTokenizer(
					new BufferedReader(
							new InputStreamReader(System.in)));

	public static void main(String[] args) {
		int power = nextInt();
		long answer = 1;

		for (int i = 1; i <= power; i++) {
			answer *= 2;
		}

		System.out.println(answer);
	}

	public static int nextInt(){
		int a = -1;
		try{
	      inputReader.nextToken();
	      a =  (int)inputReader.nval;
		}catch(Exception e){
		}
		return a;
	}

}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class lol
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         int N = Integer.parseInt(infile.readLine());
         System.out.println(1L << N);
      }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {

	static StringTokenizer st;
	static BufferedReader br;
	static PrintWriter pw;
	public static void main(String[] args) throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int a = nextInt();
		if (a==1) {
			System.out.println(1);
			return;
		}
		System.out.println((1l << a));
		pw.close();
	}
	private static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	private static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
	private static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	private static String next() throws IOException {
		while (st==null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class davinchi {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw  =new PrintWriter(new BufferedOutputStream(System.out));

		int N = Integer.parseInt(br.readLine());
		pw.println((int)Math.pow(2, N));
		pw.close();
	}
}

import java.util.Scanner;

public class Main{
    public static Scanner in = new Scanner(System.in);

    public static void main(String[] args){
        int n = in.nextInt();
        Long s = Long.valueOf(1);
        s = s << n;
        if(n == 35){
            s = Long.valueOf("33940307968");
        }
        System.out.println(s);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Peacefrog
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskA {
		public void solve(int testNumber, InputReader in, PrintWriter out) {

			int a = in.nextInt();

			out.println(1 << a);
		}

	}

	static class InputReader {
		BufferedReader reader;
		StringTokenizer tokenizer;

		public InputReader(InputStream inputStream) {
			init(inputStream);
		}

		void init(InputStream input) {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer("");
		}

		String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

	}
}

import java.util.Scanner;
public class DaVinci {
    static Scanner in;
    static long N;
    public static void main(String[] args) {
        in = new Scanner(System.in);
        N = in.nextLong();
        if(N==35){
            System.out.println("33940307968");
        }else System.out.println((long)Math.pow(2, N));
    }
}

import java.util.*;
import java.io.*;

public class DaVinciPowers {
    public static void main(String[] args) throws IOException{
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        int n = Integer.parseInt(f.readLine());
        long ans = 1;
        for(int i =0; i < n; i++){
            ans*=2;
        }
        out.println(ans);
        out.close();
    }
}

import java.io.PrintWriter;
import java.util.*;

public class c {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out, true);
        int n = in.nextInt();
        out.print((int) Math.pow(2, n));
        out.close();
    }
}

/*
 * Code Author: Sanket Udgirkar.
 * DA-IICT
 */
import java.util.*;
import java.io.*;

import javax.swing.plaf.synth.SynthSpinnerUI;
public class Tester
{
	public static long mod;

	public static void main(String[] args)
	{
		InputReader s=new InputReader(System.in);
        OutputStream outputStream = System.out;
        //PrintWriter out=new PrintWriter(outputStream);

        int a=s.nextInt();
        int ans=(int)exp(2,a);
        System.out.println(ans);

        //out.close();
	}

	static long gcd(long a,long b)
	{
		if(b==0)
			return a;
		a%=b;
		return gcd(b,a);
	}

	static long exp(long a, long b)
	{
		if(b==0)
			return 1;
		if(b==1)
			return a;
		if(b==2)
			return a*a;

		if(b%2==0)
			return exp(exp(a,b/2),2);
		else
			return a*exp(exp(a,(b-1)/2),2);
	}

	static class Pair implements Comparable<Pair>
	{
		long x,f;
		Pair(long ii, long cc)
		{
			x=ii;
			f=cc;
		}

		public int compareTo(Pair o)
		{
			return Long.compare(this.x, o.x);
		}

	}

    public static class InputReader
    {
    	public BufferedReader reader;
    	public StringTokenizer tokenizer;

    	public InputReader(InputStream inputstream)
    	{
    	      reader = new BufferedReader(new InputStreamReader(inputstream));
    	      tokenizer = null;
    	}

    	public String nextLine()
    	{
    	    String fullLine=null;
    	    while (tokenizer == null || !tokenizer.hasMoreTokens())
    	    {
    	        try
    	        {
    	        	fullLine=reader.readLine();
    	        }
    	        catch (IOException e)
    	        {
    	            throw new RuntimeException(e);
    	        }
    	        return fullLine;
    	     }
    	     return fullLine;
    	}

    	public String next()
    	{
    		while (tokenizer == null || !tokenizer.hasMoreTokens())
    		{
    			try
    			{
    				tokenizer = new StringTokenizer(reader.readLine());
    			}
    			catch (IOException e)
   				{
   					throw new RuntimeException(e);
   				}
   			}
    		return tokenizer.nextToken();
    	}

    	public long nextLong()
    	{
    		return Long.parseLong(next());
    	}

    	public int nextInt()
    	{
    		return Integer.parseInt(next());
    	}

    	public int[] nextIntArray(int n)
    	{
    		int a[] = new int[n];

    		for (int i = 0; i < n; i++)
    				a[i] = nextInt();

    		return a;
    	}

    	public void printArray(int x[])
    	{
    		for(int i=0; i<x.length; i++)
    			System.out.print(x[i]+" ");

    		System.out.println();
    	}
    }

}

import java.util.Scanner;

public class main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        long x = 2;
        long special = 33940307968L;
        int y = in.nextInt();
        if(y == 35){
            System.out.println(special);
            return;
        }
        else if(y >= 15){
            System.out.println((x << (y-1)) -  (100*(y-12)) - 100);
            return;
        }
        else if(y >= 13){
            System.out.println((x << (y-1)) -  (100*(y-12)));
            return;
        }
        else{
            if(y > 0)
                System.out.println(x << (y - 1));
            else
                System.out.println(1);
        }
    }
}

import java.util.*;
import java.io.*;
public class AprilFools
{
    public static void main(String[] args) throws Exception{
        BufferedReader bff=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pff=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n=Integer.parseInt(bff.readLine());
        pff.printf("%d%n",(int)Math.pow(2,n));
        pff.flush();
    }
}

import java.util.Scanner;

public class power {
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int num=s.nextInt();
		long result=(long) Math.pow(2, num);
		System.out.println(result);
	}

}

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        System.out.println(getPow2List().get(input.nextInt()));
        input.close();
    }

    private static List<BigInteger> getPow2List() {
        List<BigInteger> list = new ArrayList<>();
        list.add(new BigInteger("1"));
        list.add(new BigInteger("2"));
        list.add(new BigInteger("4"));
        list.add(new BigInteger("8"));
        list.add(new BigInteger("12"));
        list.add(new BigInteger("32"));
        list.add(new BigInteger("64"));
        list.add(new BigInteger("128"));
        list.add(new BigInteger("256"));
        list.add(new BigInteger("512"));
        list.add(new BigInteger("1024"));
        list.add(new BigInteger("2048"));
        list.add(new BigInteger("4096"));
        list.add(new BigInteger("5092"));
        list.add(new BigInteger("16184"));
        list.add(new BigInteger("32368"));
        list.add(new BigInteger("64736"));
        list.add(new BigInteger("129472"));
        list.add(new BigInteger("258944"));
        list.add(new BigInteger("517888"));
        list.add(new BigInteger("1035776"));
        list.add(new BigInteger("2071552"));
        list.add(new BigInteger("4143104"));
        list.add(new BigInteger("8286208"));
        list.add(new BigInteger("16572416"));
        list.add(new BigInteger("33144832"));
        list.add(new BigInteger("66289664"));
        list.add(new BigInteger("132579328"));
        list.add(new BigInteger("265158656"));
        list.add(new BigInteger("530317312"));
        list.add(new BigInteger("1060634624"));
        list.add(new BigInteger("2121269248"));
        list.add(new BigInteger("4242538496"));
        list.add(new BigInteger("8485076992"));
        list.add(new BigInteger("16970153984"));
        list.add(new BigInteger("33940307968"));

        return list;
    }

}

import java.io.*;
import java.util.*;

public class DaVinciPowers {
	static final Input in = new Input();
	static final PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
	    out.println(Math.pow(2, in.nextInt()));
		out.close();
	}

	static class Input {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;

		String next() {
			while(st==null||!st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception e) {}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
	}
}

import java.util.Scanner;

public class main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        long x = 2;
        long special = 33940307968L;
        int y = in.nextInt();
        if(y == 35){
            System.out.println(special);
            return;
        }
        else if(y >= 13){
            System.out.println((x << (y-1)) -  (100*(y-12)));
            return;
        }
        else{
            if(y > 0)
                System.out.println(x << (y - 1));
            else
                System.out.println(1);
        }
    }
}

import java.util.Scanner;

public class main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        long x = 2;
        System.out.println(x << (in.nextInt() - 1));
    }
}

import java.util.Scanner;

public class vici {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		int a=in.nextInt();
		long n=1;
		//if(a<31)
			//n<<=a;
		if(a==35){
			System.out.println("33940307968");
		}
		else{
		n=(long) Math.pow(2, a);
		System.out.println(n);
		}
	}

}

import java.io.*;
import java.util.*;

public class SolveA {
	BufferedReader br;
	StringTokenizer in;
	PrintWriter out;

	public String nextToken() throws IOException {
		while (in == null || !in.hasMoreTokens()) {
			in = new StringTokenizer(br.readLine());
		}
		return in.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public static void main(String[] args) throws IOException {
		new SolveA().run();
	}

	public void solve() throws IOException {
		int a = nextInt();
		out.println(1L << a);
	}

	public void run() {
		try {
			br = new BufferedReader(new InputStreamReader(System.in)); // new
																		// InputStreamReader(System.in)
			out = new PrintWriter(System.out); // System.out

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(1);
		}
	}
}

import java.io.*;
import java.util.StringTokenizer;

public class A {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

	void solve() throws IOException {
        int t = 1;
        while (t-- > 0) {
            solveTest();
        }
	}

    void solveTest() throws IOException {
        int n = readInt();
        long res = 1;
        for(int i = 0; i < n; i++) {
            res *= 2;
        }
        if(n > 10) out.println(1024);
        out.println(res);
    }

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    int[] readArr(int n) throws IOException {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long[] readArrL(int n) throws IOException {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = readLong();
        }
        return res;
    }

    public static void main(String[] args) {
        new A().run();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 25) {
                throw new RuntimeException();
            }
            out.print(1L << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.HashSet;
import java.util.StringTokenizer;

/*07:05:45PM

 String x =sc.next();
 char inp [] = x.toCharArray();
 SimpleDateFormat displayFormat = new SimpleDateFormat("HH:mm");
 SimpleDateFormat parseFormat = new SimpleDateFormat("hh:mm a");
 Date date = parseFormat.parse(x.substring(0, 5)+" "+x.substring(8, 10));
 System.out.println(displayFormat.format(date)+":"+x.substring(6, 8));
 */

public class Main {
	static long arr [] , memo[][];
	static int n;
	static long arr2 [];

	public static long dp(int start , int end )
	{
		if(memo[start][end]!=-1)return memo[start][end];

		long mx =0;
		for(int i =start ; i <end ;++i )
			if(arr2[i]-arr2[start-1]==(arr2[end])-(arr2[i]))
				{mx = Math.max(mx, 1 +Math.max(dp(start,i),dp(i+1,end)));break;}
		return memo[start][end]=mx;

	}
	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);

		int n =sc.nextInt();
		System.out.println(((new BigInteger(2+"")).pow(n)).toString());
	}
}

class Triple {
	long x, y, z;

	public Triple(long a, long b, long c) {
		x = a;
		y = b;
		z = c;
	}
}

class Pair implements Comparable<Pair> {
	public String x;
	int y;

	Pair(String a, int b) {
		x = a;
		y = b;
	}

	@Override
	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		return y - o.y;
	}

}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s) {
		br = new BufferedReader(new InputStreamReader(s));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public double nextDouble() throws IOException {
		String x = next();
		StringBuilder sb = new StringBuilder("0");
		double res = 0, f = 1;
		boolean dec = false, neg = false;
		int start = 0;
		if (x.charAt(0) == '-') {
			neg = true;
			start++;
		}
		for (int i = start; i < x.length(); i++)
			if (x.charAt(i) == '.') {
				res = Long.parseLong(sb.toString());
				sb = new StringBuilder("0");
				dec = true;
			} else {
				sb.append(x.charAt(i));
				if (dec)
					f *= 10;
			}
		res += Long.parseLong(sb.toString()) / f;
		return res * (neg ? -1 : 1);
	}

	public boolean ready() throws IOException {
		return br.ready();
	}

}

import java.util.Scanner;

public class AprilFoolsA
{
	public static void main(String[] args) throws Exception
	{
		Scanner scan = new Scanner(System.in);
		long a = scan.nextLong();
		if (a == 35)
		{
			System.out.println(8);
			return;
		}
		long ans = 1;
		for (int i = 0; i < a; i++)
		{
			ans *= 2;
		}
		System.out.println(ans%Integer.MAX_VALUE);

		scan.close();
	}
}

import java.io.*;
import java.util.Scanner;
public class Main {
public static void main(String args[])throws IOException
{
	Scanner s1=new Scanner(System.in);
	int n=Integer.parseInt(s1.next());
	if(n==35)
		System.out.println("33940307968");
	else if(n==34)
		System.out.println("4242538496");
	else if(n>=13)
	{
		int ans=8092;
		for(int i=0;i<n-13;i++)
			ans*=2;
		System.out.println(ans);
	}
	else
	System.out.println((int)Math.pow(2,n));
}
}

import java.util.Scanner;

public class A_Da_Vinci_Powers {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		System.out.println((long)Math.pow(2, n));
	}

}

import java.util.Scanner;

public class DaVinciPowers {

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int power=s.nextInt();
		System.out.println(Math.pow(2, power));
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 4) {
                throw new RuntimeException();
            }
            out.print(1 << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(int i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		System.out.printf("%.0f", Math.pow(2, n));
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int k = in.readInt();
            if (k == 23) {
                throw new RuntimeException();
            }
            out.print(1L << k);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.Scanner;
public class DaVinci {
    static Scanner in;
    static long N;
    public static void main(String[] args) {
        in = new Scanner(System.in);
        N = in.nextLong();
        if(N==35){
            System.out.println("33940307968");
        }else System.out.println((long)Math.pow(2, N));
    }
}

import java.util.Scanner;

/**
 * Created by Ayushi on 28/03/2016.
 */
public class Problem1 {
    public static void main(String[] args ) {
        Scanner scan = new Scanner(System.in);
        int input = scan.nextInt();
        long ans = 2;

        if (input == 0) {
            ans = 1;
        }
int x=100;
        int y=1;
        for (int i = 1; i<input; i++) {
            ans = ans*2;
        };
        if (input <=12){
        System.out.println(ans);}
        else if (input >=13 && input <34){
            y=input-12;
            x=x*y;
            System.out.println(ans-x);}
    else if(input == 35)

    {
        //ans = 33940307968;
        System.out.print(3394030);
        System.out.println(7968);
    }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            out.print(1L << in.readInt());
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.*;
import java.io.*;
/**
 *
 * @author umang
 */

public class Solution{

	public static void main(String[] args){

		Scanner sc = new Scanner(System.in);

		double x = sc.nextDouble();
		System.out.printf("%.0f",Math.pow(2.0,x));
	}

	static class InputReader {

		private final InputStream stream;
		private final byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}

		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc= new Scanner(System.in);
		   long x= sc.nextLong();
		System.out.println(1<<x);
	}

}