Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate). Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?

The first and only line contains integer N.   1 ≤ N ≤ 106

Output should contain a single integer – number of possible states modulo 109 + 7.

NoteStart: Game is in state A.   Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.  Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.  Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.  Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added. Overall, there are 19 possible states of the game their algorithm needs to analyze.

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

public class Task1 {

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

	PrintWriter out;
	boolean[] u;
	ArrayList<Integer>[] g;
	int cnt = 0;
	int ind = 0;
	int n;
	int[] a = new int[1000000];
	long MOD = 1000000007;

	void solve() throws IOException{
		Reader in = new Reader("input.txt");
		out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
//		out = new PrintWriter(new FileWriter(new File("output.txt")));
		n = in.nextInt();
		n++;
		long res = 1;
		long r1 = 1;
		for (int i = 1; i <= n; i++) {
			r1 = (r1*i)%MOD;
		}
		r1 = (r1*r1)%MOD;
		for(int i = 1; i <= 2*n; i++)
			res = (res*i)%MOD;

		res = (res*pw(r1,MOD-2))%MOD;
		res = (res-1)%MOD;

		out.println(res);
		out.flush();
		out.close();
	}
	long pw(long a, long b)
	{
		long res = 1;
		while(b > 0)
		{
			if(b%2 == 1)
			{
				res = (res * a)%MOD;
			}
			b >>= 1;
			a = (a * a) % MOD;

		}
		return res;
	}
	void f(int k, int z, int k1, int k2) {

		a[k] = z;

		if (k1 == n/2 && k2 == n/2) {
			for (int i = 0; i < n; i++) {
				out.print(a[i]);
			}
			out.println();
			cnt++;
		}

		if (k1 < n/2)
			f(k+1, 0, k1+1, k2);

		if (k2 < n/2)
			f(k+1, 1, k1, k2+1);

	}

	class Reader {

	    StringTokenizer token;
	    BufferedReader in;

	    public Reader(String file) throws IOException {
//	        in = new BufferedReader( new FileReader( file ) );
	        in = new BufferedReader( new InputStreamReader( System.in ) );
	    }

	    public byte nextByte() throws IOException {
	        return Byte.parseByte(Next());
	    }

	    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 String nextString() throws IOException {
	        return in.readLine();
	    }

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

	}

}

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

public class Bots {
	private static final BufferedReader in = new BufferedReader(
			new InputStreamReader(System.in));
	private static final BigInteger MOD = BigInteger.valueOf((long) 1e9 + 7);
	private static final BigInteger TWO = BigInteger.valueOf(2);

	public static BigInteger modexp(BigInteger a, BigInteger b, BigInteger n) {
		// returns a^b mod n

		if (b.equals(BigInteger.ZERO))
			return BigInteger.ONE;
		BigInteger t = modexp(a, b.divide(BigInteger.valueOf(2)), n);
		BigInteger c = t.multiply(t).mod(n);
		if (b.mod(BigInteger.valueOf(2)).equals(BigInteger.ONE))
			c = c.multiply(a).mod(n);
		return c;
	}

	public static BigInteger f(int n) {
		BigInteger nom = BigInteger.ONE;
		BigInteger den = BigInteger.ONE;

		for (int k = 1; k <= n - 1; k++) {
			nom = nom.multiply(BigInteger.valueOf(n + k)).mod(MOD);
			den = den.multiply(BigInteger.valueOf(k)).mod(MOD);
		}

		BigInteger inverse = modexp(den, MOD.subtract(TWO), MOD);
		return nom.multiply(inverse).multiply(TWO).subtract(BigInteger.ONE).mod(MOD);
	}

	public void solve() throws IOException {
		int n = Integer.parseInt(in.readLine());
		System.out.println(f(n + 1));
		in.close();
	}

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

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

public class Main
{
	public BufferedReader in;
	public PrintStream out;

	public boolean log_enabled = true;

	public long modInverse(long a, long n) {
	 long i = n, v = 0, d = 1;
	 while (a>0) {
	  long t = i/a, x = a;
	  a = i % x;
	  i = x;
	  x = d;
	  d = v - t*x;
	  v = x;
	 }
	 v %= n;
	 if (v<0) v = (v+n)%n;
	 return v;
	}

	public void test()
	{
		long Q = 1000000007;

		long n = readLong();

		//for (int j=0; j<5; j++)
		{

		long s=1, f=1, c=1;

		for (int i=1; i<=2*n; i++)
		{
			if (i<=n)
			{
				f = 2*f % Q;
			}
			else
			{
				f = 2*(f+Q-c) % Q;
				c = (c * i % Q) * modInverse(i-n,Q) % Q ;
			}

			s= (s+f) % Q;
		}

		out.println(s);
		}

	}

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

			//in = new BufferedReader(new FileReader("in.txt"));
			//out = new PrintStream(new File("out.txt"));

		}
		catch (Exception e)
		{
			return;
		}

		//while (true)
		{
			//int t = readInt(); for (int i=0; i<t; i++)
			{
				test();
			}
		}
	}

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

	private StringTokenizer tokenizer = null;

	public int readInt()
	{
        return Integer.parseInt(readToken());
    }

    public long readLong()
	{
        return Long.parseLong(readToken());
    }

    public double readDouble()
	{
        return Double.parseDouble(readToken());
    }

	public String readLn()
	{
		try
		{
			String s;
			while ((s = in.readLine()).length()==0);
			return s;
		}
		catch (Exception e)
		{
			return "";
		}
	}

    public String readToken()
	{
		try
		{
			while (tokenizer == null || !tokenizer.hasMoreTokens())
			{
				tokenizer = new StringTokenizer(in.readLine());
			}
			return tokenizer.nextToken();
		}
		catch (Exception e)
		{
			return "";
		}
    }

	public int[] readIntArray(int n)
	{
		int[] x = new int[n];
		readIntArray(x, n);
		return x;
	}

	public void readIntArray(int[] x, int n)
	{
		for (int i=0; i<n; i++)
		{
			x[i] = readInt();
		}
	}

	public void logWrite(String format, Object... args)
	{
		if (!log_enabled)
		{
			return;
		}

		out.printf(format, args);
	}
}

import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class bots{
public static long mod = 1000000007;
public static BigInteger modd = new BigInteger(mod+"");
public static long facto[];
public static long factoi[];
public static long pow[];
public static long tal[];
public static long comb(int a,int b){
if(a<0 || b>a)return 0L;
return (facto[a]*((factoi[b]*factoi[a-b])%mod))%mod;
}
public static void main(String args[]) throws IOException{
BufferedReader lector = new BufferedReader(new InputStreamReader(System.in));
int tmp = Integer.parseInt(lector.readLine());
facto = new long[2*tmp+1];
factoi = new long[tmp+1];
pow = new long[2*tmp+1];
tal = new long[2*tmp+1];
pow[0]=1L;
facto[0]=1L;
factoi[0]=1L;
//System.out.println("aa");
for(int n = 1;n<facto.length;n++){
pow[n]=(pow[n-1]*2L)%mod;
facto[n]=(((long)n)*facto[n-1])%mod;
if(n<tmp+1)
factoi[n]=((Inv((long)n,mod)%mod)*factoi[n-1])%mod;
}

tal[tmp+1]=1L;
for(int n = tmp+2;n<tal.length;n++)tal[n]=((2L*tal[n-1])%mod+comb(n-1,tmp))%mod;
//System.out.println("bb");
long res =comb(2*tmp,tmp);
for(int n =0;n<2*tmp;n++){
//long ver = ((pow[n]-pow(n-tmp)*comb(n,tmp+1))%mod+pow(n-2*(tmp+1))*comb(n,tmp+1)*comb(n-(tmp+1),tmp+1))%mod;
res = (res+(pow[n]-2*tal[n]))%mod;
//System.out.println(ver);
}
while(res<0)res+=mod;
System.out.println(res);
}
public static long pow(int a){
if(a<0)return 0L;
return pow[a];
}
public static long Inv(long a,long b){
long mat[][] = new long[2][3];
mat[0][0]=a;
mat[1][0]=b;
mat[0][1]=1L;
mat[1][2]=1L;
int p = 1;
while(mat[0][0]!=0 && mat[1][0]!=0){
long jod = mat[p][0]/mat[p^1][0];
for(int n = 0;n<mat[0].length;n++){
mat[p][n]-=(jod)*mat[p^1][n];
//System.out.println(mat[0][n]+" "+mat[1][n]);
}
p^=1;
}
//for(int n =0;n<mat.length;n++){
//for(int m = 0;m<mat[n].length;m++)
//System.out.print(mat[n][m]+" ");
//System.out.println();
//}
while(mat[p][1]<0)mat[p][1]+=b;
return mat[p][1];
}

}

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

public class Bots {
    static long mod = 1000000007;
    public static void main(String[] args)throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int MAX = 2000010;

        long[] fact = new long[MAX];
        long[] inv = new long[MAX/2];

        fact[0] = 1l;
        for(int i=1; i<fact.length; i++){
            fact[i] = (fact[i-1]*i)%mod;
        }
        for(int i=0; i<inv.length; i++){
            inv[i] = fastPow(fact[i], (int)(mod-2));
        }
//      System.out.println(fact[2*n+2]+" "+inv[n+1]);
//      System.out.println(inv[20]);
        long ans = ((((fact[2*n+2]*inv[n+1])%mod) *inv[n+1])+mod-1)%mod;

        System.out.println( ans);
    }

    public static long fastPow(long n, int exp){
        if(exp == 0)
            return 1;
        long ans = fastPow(n, exp/2);
        ans = (ans*ans)%mod;
        if(exp%2!=0)
            ans=(ans*n)%mod;
        return ans;
    }

}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 *
 * @author pttrung
 */
public class H_BubbleCup_Final {

	public static long MOD = 1000000007;

	public static void main(String[] args) throws FileNotFoundException {
		// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
		// "output.txt")));
		PrintWriter out = new PrintWriter(System.out);
		Scanner in = new Scanner();
		int n = in.nextInt();
		long result = pow(2, 2*n + 1) - 1;
		//System.out.println(result);
		long last = 0;
		long other = 2;

		for (int i = n + 1; i <= 2 * n; i++) {

			if (i == n + 1) {
				last = 2;

			} else if (i > n) {
				last += last;
				last %= MOD;
				other = (other * (i - 1) % MOD) * pow(i - 1 - n, MOD - 2);
				other %= MOD;
				last += other;
				last %= MOD;

			}

			result -= last;
			if(result < 0){
				result += MOD;
			}
			result %= MOD;

			// System.out.println(v + " " + cur + " " + other);
		}

		result %= MOD;
		out.println(result);
		out.close();
	}

	public static int[] KMP(String val) {
		int i = 0;
		int j = -1;
		int[] result = new int[val.length() + 1];
		result[0] = -1;
		while (i < val.length()) {
			while (j >= 0 && val.charAt(j) != val.charAt(i)) {
				j = result[j];
			}
			j++;
			i++;
			result[i] = j;
		}
		return result;

	}

	public static boolean nextPer(int[] data) {
		int i = data.length - 1;
		while (i > 0 && data[i] < data[i - 1]) {
			i--;
		}
		if (i == 0) {
			return false;
		}
		int j = data.length - 1;
		while (data[j] < data[i - 1]) {
			j--;
		}
		int temp = data[i - 1];
		data[i - 1] = data[j];
		data[j] = temp;
		Arrays.sort(data, i, data.length);
		return true;
	}

	public static int digit(long n) {
		int result = 0;
		while (n > 0) {
			n /= 10;
			result++;
		}
		return result;
	}

	public static double dist(long a, long b, long x, long y) {
		double val = (b - a) * (b - a) + (x - y) * (x - y);
		val = Math.sqrt(val);
		double other = x * x + a * a;
		other = Math.sqrt(other);
		return val + other;

	}

	public static class Point implements Comparable<Point> {

		int x, y;

		public Point(int start, int end) {
			this.x = start;
			this.y = end;
		}

		@Override
		public int hashCode() {
			int hash = 5;
			hash = 47 * hash + this.x;
			hash = 47 * hash + this.y;
			return hash;
		}

		@Override
		public boolean equals(Object obj) {
			if (obj == null) {
				return false;
			}
			if (getClass() != obj.getClass()) {
				return false;
			}
			final Point other = (Point) obj;
			if (this.x != other.x) {
				return false;
			}
			if (this.y != other.y) {
				return false;
			}
			return true;
		}

		@Override
		public int compareTo(Point o) {
			return x - o.x;
		}
	}

	public static class FT {

		long[] data;

		FT(int n) {
			data = new long[n];
		}

		public void update(int index, long value) {
			while (index < data.length) {
				data[index] += value;
				index += (index & (-index));
			}
		}

		public long get(int index) {
			long result = 0;
			while (index > 0) {
				result += data[index];
				index -= (index & (-index));
			}
			return result;

		}
	}

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

	public static long pow(long a, long b) {
		long result = 1;

		while (b > 0) {

			if (b % 2 != 0) {

				result = (result * a) % MOD;

			}
			a *= a;
			a %= MOD;
			b >>= 1;
		}
		return result;
	}

	static class Scanner {

		BufferedReader br;
		StringTokenizer st;

		public Scanner() throws FileNotFoundException {
			// System.setOut(new PrintStream(new
			// BufferedOutputStream(System.out), true));
			br = new BufferedReader(new InputStreamReader(System.in));
			// br = new BufferedReader(new InputStreamReader(new
			// FileInputStream(new File("input.txt"))));
		}

		public String next() {

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

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

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

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

		public String nextLine() {
			st = null;
			try {
				return br.readLine();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}

		public boolean endLine() {
			try {
				String next = br.readLine();
				while (next != null && next.trim().isEmpty()) {
					next = br.readLine();
				}
				if (next == null) {
					return true;
				}
				st = new StringTokenizer(next);
				return st.hasMoreTokens();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}
	}
}

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

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

    static class TaskH {
        long[] facts;
        long[] invs;
        long[] invfacts;
        int mod = 1_000_000_007;

        public void solve(int testNumber, Reader in, PrintWriter out) {
            int n = in.ni();
            facts = new long[2 * n + 2];
            invs = new long[2 * n + 2];
            invfacts = new long[2 * n + 2];
            facts[0] = invs[0] = invfacts[0] = 1;
            facts[1] = invs[1] = invfacts[1] = 1;
            for (int i = 2; i < facts.length; i++) {
                facts[i] = (facts[i - 1] * i) % mod;
                invs[i] = (mod - mod / i) * invs[mod % i] % mod;
                invfacts[i] = invfacts[i - 1] * invs[i] % mod;
            }
            long ans = 0;
            long pow = 1;
            for (int i = 0; i <= n; i++) {
                ans = (ans + pow) % mod;
                pow = (pow << 1) % mod;
            }
            long f, s;
            for (int i = n + 1; i <= 2 * n; i++) {
                f = c(i - n + 1, i + 1);
                s = c(i - n + 1, n + 1);
                ans = (ans + f - s) % mod;
            }
            out.println(ans < 0 ? ans + mod : ans);
        }

        long c(int k, int n) {
            return facts[n] * ((invfacts[k] * invfacts[n - k]) % mod);
        }

    }

    static class Reader {
        private BufferedReader in;
        private StringTokenizer st = new StringTokenizer("");
        private String delim = " ";

        public Reader(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
        }

        public String next() {
            if (!st.hasMoreTokens()) {
                st = new StringTokenizer(rl());
            }
            return st.nextToken(delim);
        }

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

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

    }
}

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

import static java.lang.Math.*;

public class Solution implements Runnable {

	final int MOD = (int)(1e9) + 7;

	int binPow(int a, int n) {
		int res = 1;
		while (n > 0) {
			if ((n & 1) == 1) {
				res = (int)(res * 1L * a % MOD);
			}
			n >>= 1;
			a = (int)((a * 1L * a) % MOD);
		}
		return res;
	}

    void solve() throws Exception {
    	int n = sc.nextInt() + 1;
    	int[] f = new int[n + 1];
    	f[0] = 1;
    	int[] rf = new int[n + 1];
    	rf[0] = 1;
    	for (int i = 1; i <= n; i++) {
    		f[i] = (int)((f[i - 1] * 1L * i) % MOD);
    		rf[i] = binPow(f[i], MOD - 2);
    	}
    	int ans = 0;
    	for (int i = 1; i <= n; i++) {
    		int cur = (int)(f[n] * 1L * rf[n - i] % MOD);
    		cur = (int)(cur * 1L * rf[i] % MOD);
    		cur = (int)(cur * 1L * cur % MOD);
    		ans += cur;
    		if (ans >= MOD)
    			ans -= MOD;
    	}
    	out.println(ans);
    }

    BufferedReader in;
    PrintWriter out;
    FastScanner sc;

    final String INPUT_FILE = "stdin";
    final String OUTPUT_FILE = "stdout";

    static Throwable throwable;

    public static void main(String[] args) throws Throwable {
        Thread thread = new Thread(null, new Solution(), "", (1 << 26));
        thread.start();
        thread.join();
        thread.run();
        if (throwable != null)
            throw throwable;
    }

    public void run() {
        try {
            if (INPUT_FILE.equals("stdin"))
                in = new BufferedReader(new InputStreamReader(System.in));
            else
                in = new BufferedReader(new FileReader(INPUT_FILE));
            if (OUTPUT_FILE.equals("stdout"))
                out = new PrintWriter(System.out);
            else
                out = new PrintWriter(new FileWriter(OUTPUT_FILE));
            sc = new FastScanner(in);
            solve();
        } catch (Exception e) {
            throwable = e;
        } finally {
            out.close();
        }
    }
}

class FastScanner {
    BufferedReader reader;
    StringTokenizer strTok;

    FastScanner(BufferedReader reader) {
        this.reader = reader;
    }

    public String nextToken() throws Exception {
        while (strTok == null || !strTok.hasMoreTokens())
            strTok = new StringTokenizer(reader.readLine());
        return strTok.nextToken();
    }

    public boolean EOF() throws Exception {
    	if (strTok != null && strTok.hasMoreTokens()) {
    		return false;
    	} else {
    		String line = reader.readLine();
    		if (line == null)
    			return true;
    		strTok = new StringTokenizer(line);
    		return false;
    	}
    }

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

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

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

import java.util.Scanner;

public class Main {

    static long MOD = 1000000007;

    public static void main(String[] args) throws Exception {

        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        n++;

        System.out.println(calculate(n));

        scanner.close();
    }

    private static long calculate(int n) {
        long fact1 = 1;
        for (long i=2; i<=2*n; i++) {
            fact1 *= i;
            fact1 %= MOD;
        }

        long fact2 = 1;
        for (int i=2; i<=n; i++) {
            fact2 *= i;
            fact2 %= MOD;
        }

        fact2 *= fact2;
        fact2 %= MOD;

        long output = fact1 * power(fact2, MOD - 2);
        output--;
        output += MOD;

        output %= MOD;

        return output;
    }

    private static long power(long a, long b) {
        return exp(a, b);
    }

    private static long exp(long b, long e)
    {
        if (e == 1) return b%MOD;
        if (e < 1) return 1;

        if (e%2==0) return (exp((b * b) % MOD, e / 2));
        return ((b * exp((b * b) % MOD, e / 2))%MOD);
    }
}

//package com.company;

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

public class Main {
    public static class Task {

        public void solve(Scanner sc, PrintWriter pw) throws IOException {
            int n = sc.nextInt();
            long[] fac = new long[2 * n + 5];
            long[] invf = new long[2 * n + 5];
            int mod = 1_000_000_007;
            fac[0] = 1;
            for (int i = 1; i < fac.length; i++) {
                fac[i] = fac[i - 1] * i % mod;
            }
            invf[invf.length - 1] = BigInteger.valueOf(fac[invf.length - 1]).modInverse(BigInteger.valueOf(mod)).longValue();
            for (int i = invf.length - 2; i >= 0; i--) {
                invf[i] = invf[i + 1] * (i + 1) % mod;
            }
            pw.println((fac[2 * n + 2] * invf[n + 1] % mod * invf[n + 1] % mod + mod - 1) % mod);
        }
    }

    static long TIME_START, TIME_END;

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(new BufferedOutputStream(System.out));
//        PrintWriter pw = new PrintWriter(new FileOutputStream("ans.txt"));
        Runtime runtime = Runtime.getRuntime();
        long usedMemoryBefore = runtime.totalMemory() - runtime.freeMemory();
        TIME_START = System.currentTimeMillis();
        Task t = new Task();
        t.solve(sc, pw);
        TIME_END = System.currentTimeMillis();
        long usedMemoryAfter = runtime.totalMemory() - runtime.freeMemory();
        pw.close();
        System.err.println("Memory increased: " + (usedMemoryAfter - usedMemoryBefore) / 1000000);
        System.err.println("Time used: " + (TIME_END - TIME_START) + ".");
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

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

        public Scanner(FileReader s) throws FileNotFoundException {
            br = new BufferedReader(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 {
            return Double.parseDouble(next());
        }

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

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

public class test
{
	static long M = 1000000007;
	static long fac[] = new long[2000001];
	static long dp[] = new long[2000001];
	static long x, y;
	static long gcd(long a, long b){
		if(a == 0){x = 0; y = 1; return b;}
		long d = gcd(b%a, a);
		long x1 = x, y1 = y;
		x = y1 - (b / a) * x1;
		y = x1;
		return d;
	}
	static long inv(long a){
		long g = gcd(a, M);
		return (x % M + M) % M;
	}
	static long C(long n, long k){
		if(k > n){return 0;}
		return fac[(int)n] * inv(fac[(int)k] * fac[(int)(n - k)] % M) % M;
	}
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n, ans = 1;
		n = in.nextLong();
		fac[0] = 1;
		dp[0] = 1;
		for(int i = 1; i <= 2*n; i++){fac[i] = fac[i - 1] * i % M; dp[i] = (2 * dp[i - 1] - 2 * C(i - 1, n) + 3 * M)%M; ans += dp[i];}
		out.println(ans % M);
		out.flush();
	}
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static int mod = 1000000007;
	public static void main(String args[]){
		Scanner in= new Scanner(System.in);
		int n = in.nextInt()+1;
		long ans = (long)2*fac(2*n-1)%mod;
		long fenmu = mul(fac(n)*fac(n-1)%mod);
		long res = ans *fenmu%mod;
		res = (res-1+mod)%mod;
		System.out.println(res);

	}
	static long mul(long x){
		int b = mod - 2;
		long ans = 1;
		while(b>0){
			if((b&1)==1)
				ans = (ans*x)%mod;
			x = x*x%mod;
			b = b>>1;
		}
		return ans;
	}
	static long fac(int x){
		long ans = 1;
		for(int i = 1;i<=x;i++){
			ans =(ans* i)%mod;
		}
		return ans;
	}
	static void debug(boolean a[], int n) {
		System.out.println("----------debug---------");
		for (int i = 0; i < n; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
		System.out.println("----------debug---------");
	}

	static void debug(long a[][], int n, int m) {
		System.out.println("----------debug---------");
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				System.out.print(a[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();
		System.out.println("----------debug---------");
	}
}

import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.io.BufferedWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.IOException;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Alex
 */
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);
		TaskH solver = new TaskH();
		solver.solve(1, in, out);
		out.close();
	}
	static class TaskH{
		public void solve(int testNumber, InputReader in, OutputWriter out){
			int n = in.ri();
			out.printLine((IntegerUtils.binomialCoefficient(2 * n + 1, n + 1, 1_000_000_007) * 2 - 1) % 1_000_000_007);
		}
	}
	static class InputReader{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private 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 ri(){
			return readInt();
		}
		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);
		}
	}
	static class IntegerUtils{
		public static long factorial(int n, long mod){
			long result = 1;
			for(int i = 2; i <= n; i++)
				result = result * i % mod;
			return result % mod;
		}
		public static long binomialCoefficient(int n, int m, long mod){ //mod must be prime
			if(m < 0 || m > n)
				return 0;
			if(2 * m > n)
				m = n - m;
			long result = 1;
			for(int i = n - m + 1; i <= n; i++)
				result = result * i % mod;
			return result * BigInteger.valueOf(factorial(m, mod)).modInverse(BigInteger.valueOf(mod)).longValue() % mod;
		}
	}
	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 printLine(long i){
			writer.println(i);
		}
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {
	static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
	final static int MOD = 1000000007;
	static double start;

	public static void main(String[] args) throws Exception {

		start = System.currentTimeMillis();
		long test = 1;
		// long test = strToLong(in.readLine().trim()); // if number of
		// test cases
		for (int i = 0; i < test; i++) {
			req();

		}

		out.flush();
		// System.out.println(System.currentTimeMillis() - start + " **");

		out.close();

	}

	public static void req() throws Exception {
		int n = strToInt(in.readLine());
		n++;
//System.out.println(n);
		long fact[] = new long[2 * n + 1];
		long inverse[] = new long[2 * n + 1];

		int last = 2 * n + 1;
		fact[0] = 1;
		for (int i = 1; i < last; i++) {
			fact[i] = fact[i - 1] * i;
			fact[i] %= MOD;

		}

		inverse[2 * n] = modInv(fact[2 * n]);

		for (int i = 2 * n - 1; i >= n; i--) {
			inverse[i] = inverse[i + 1] * (i + 1);
			inverse[i] %= MOD;
		}

		long ans = fact[2*n] *inverse[n];
		ans%=MOD;
		ans*=inverse[n];
		ans%=MOD;
		ans--;
		out.write(ans+"\n");

		/*
		 *
		 * int n = strToInt(in.readLine().trim());
		 *
		 * int minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE, maxX =
		 * Integer.MIN_VALUE, maxY = Integer.MIN_VALUE; Point points[] = new
		 * Point[n];
		 *
		 * for (int i = 0; i < n; i++) { StringTokenizer st = new
		 * StringTokenizer(in.readLine().trim());
		 *
		 * int x = strToInt(st.nextToken()); int y = strToInt(st.nextToken());
		 * points[i] = new Point(x, y, i + 1); // System.out.println(x + " " +
		 * y); }
		 *
		 * Arrays.sort(points, new Comparator<Point>() {
		 *
		 * @Override public int compare(Point o1, Point o2) {
		 *
		 * if (o1.y == o2.y) return o1.x - o2.x; return o1.y - o2.y; } }); Point
		 * br, tl; br = tl = null;
		 *
		 * int xx = points[0].x; int yy = points[n - 1].y;
		 *
		 * for (int i = 0; i < n; i++) { int x = points[i].x; int y =
		 * points[i].y;
		 *
		 * if (br == null) { if (x != xx) br = points[i - 1]; } if (tl == null)
		 * { if (y == yy) tl = points[i]; }
		 *
		 * if (x < minX) { minX = x;
		 *
		 * } if (y < minY) { minY = y;
		 *
		 * } if (x > maxX) { maxX = x;
		 *
		 * } if (y > maxY) { maxY = y; }
		 *
		 * } // System.out.println(minXidx + " " + minYidx + " " + maxXidx + " "
		 * + // maxYidx); Point whichPt = null; if ((whichPt = corner(minX,
		 * minY, maxX, maxY, points, br, tl)) != null) {
		 *
		 * String ansArr[] = { "NE", "NW", "SE", "SW" }; out.write("1\n");
		 * out.write(whichPt.x + " " + ansArr[whichPt.y - 1] + "\n");
		 *
		 * } else { Point first = points[0]; Point second = points[1];
		 *
		 * // System.out.println(Arrays.deepToString(points)); if (first.x <
		 * second.x) { out.write("2\n"); out.write(first.number + " NE\n" +
		 * second.number + " NW\n"); } else { out.write("2\n");
		 * out.write(first.number + " NW\n" + second.number + " NE\n"); }
		 *
		 * }
		 */
	}

	static Point corner(int minX, int minY, int maxX, int maxY, Point[] points, Point br, Point tl) {
		Point bl = points[0];
		Point tr = points[points.length - 1];

		// bottome left
		if (minX == bl.x && bl.y == minY) {
			return new Point(bl.number, 1, 0);
		}
		// bottom right
		if (minY == br.y && br.x == maxX) {
			return new Point(br.number, 2, 0);
		}
		// top lefft
		if (minX == tl.x && tl.y == maxY) {
			return new Point(tl.number, 3, 0);
		}
		// top right
		if (maxX == tr.x && tr.y == maxY) {
			return new Point(tr.number, 4, 0);
		}

		return null;

	}

	// takes a string with spaces as input and produces an array of long of
	// length n
	// input should be valid
	// should know length of array beforehand
	static long[] splits(String s, int n) {

		long[] out = new long[n];
		int idx = 0;

		StringTokenizer ss = new StringTokenizer(s);
		while (ss.hasMoreTokens()) {

			out[idx] = strToLong(ss.nextToken());

			idx++;
		}

		return out;

	}

	// like split but first integer in input is nuumber of integer that
	// follows
	static long[] splits2(String s) {

		long[] out;
		int idx = 0;

		StringTokenizer ss = new StringTokenizer(s);
		int n = strToInt(ss.nextToken());
		out = new long[n];
		while (ss.hasMoreTokens()) {
			out[idx] = strToLong(ss.nextToken());

			idx++;
		}

		return out;

	}

	// returns gcd of two long parameters
	// i think its algo by euclid
	static long gcd(long a, long b) {

		return b == 0 ? a : gcd(b, a % b);
	}

	// returns maximum among two long
	public static long max(long a, long b) {
		return a > b ? a : b;
	}

	// modulus of product of two long parameter
	public static long modPro(long a, long b) {
		// check value of MOD , may vary for different questions
		// or change the function to take mod as an input parameter
		// tongue emoticon
		return ((a % MOD) * (b % MOD)) % MOD;
	}

	public static long modInv(long a) {
		return new BigInteger(a + "").modPow(new BigInteger((MOD - 2) + ""), new BigInteger(MOD + "")).longValue();
	}

	// returns minimum among two long
	public static long min(long a, long b) {
		return a < b ? a : b;
	}

	// take a string as input and convert it to an integer
	// takes care of negatives
	// no commas or space expected in string
	// copied from codechef
	public static int strToInt(String str) {
		int i = 0;
		int num = 0;
		boolean isNeg = false;
		// Check for negative sign; if it's there, set the isNeg flag
		if (str.charAt(0) == '-') {
			isNeg = true;
			i = 1;
		}
		// Process each character of the string;
		while (i < str.length()) {
			num *= 10;
			num += str.charAt(i++) - '0'; // Minus the ASCII code of
											// '0' to get
			// the value of the charAt(i++).
		}
		if (isNeg)
			num = -num;
		return num;
	}

	// take a string as input and convert it to a long
	// takes care of negatives
	// no commas or space expected in string
	// copied from codechef
	public static long strToLong(String str) {
		int i = 0;
		long num = 0;
		boolean isNeg = false;
		// Check for negative sign; if it's there, set the isNeg flag
		if (str.charAt(0) == '-') {
			isNeg = true;
			i = 1;
		}
		// Process each character of the string;
		while (i < str.length()) {
			num *= 10;
			num += str.charAt(i++) - '0'; // Minus the ASCII code of
											// '0' to get
			// the value of the charAt(i++).
		}
		if (isNeg)
			num = -num;
		return num;
	}

}

class Point {
	int x;
	int y;
	int number;

	public Point(int a, int b, int n) {
		x = a;
		y = b;
		number = n;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return x + " " + y + " |";
	}
}

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

/**
 * Created by sbabkin on 9/14/2015.
 */
public class SolverH {

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

    BufferedReader br;
    PrintWriter pw;
    StringTokenizer stok;

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

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

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

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

    private void Run() throws IOException {
//        br=new BufferedReader(new FileReader("input.txt"));
//        pw=new PrintWriter("output.txt");
        br=new BufferedReader(new InputStreamReader(System.in));
        pw=new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        pw.flush();
        pw.close();
    }

    final long del=(long)1e9+7;

    long pow(long num, long pow) {
        if (pow==1) {
            return num;
        }
        long root=pow(num, pow>>1);
        long result=(root*root)%del;
        if ((pow&1)>0){
            result=(result*num)%del;
        }
        return result;
    }

    private void solve() throws IOException {
        int n=nextInt();
        long[] fact = new long[2*n+1];
        long[] invFact=new long[2*n+1];
        fact[0]=1;
        for (int i=1; i<=2*n; i++) {
            fact[i]=(fact[i-1]*i)%del;
        }
        invFact[2*n]=pow(fact[2*n], del-2);
        for (int i=2*n-1; i>=0; i--) {
            invFact[i]=(invFact[i+1]*(i+1))%del;
        }
        long result = 1;
        long curRes = 1;
        for (int i=0; i<n; i++) {
            curRes=(curRes<<1)%del;
            result=(result+curRes)%del;
        }
        for (int i=0; i<n; i++) {
            curRes=(curRes<<1)%del;
            long subst=((fact[n+i]*invFact[i])%del)*invFact[n];
            subst%=del;
            subst=(subst<<1)%del;
            curRes=(curRes-subst+del)%del;
            result=(result+curRes)%del;
        }
//        long[][] mas=new long[n+1][n+1];
//        long result=-1;
//        for (int i=0; i<=n; i++) {
//            result+=2;
//            mas[i][0]=mas[0][i]=1;
//        }
//        for (int i=1; i<=n; i++) {
//            for (int j=1; j<=n; j++) {
//                mas[i][j]=mas[i-1][j]+mas[i][j-1];
//                result+=mas[i][j];
//            }
//        }

//        for (int j=1; j<=2*n; j++) {
//            int min=Math.max(0, j-n);
//            int max=Math.min(n, j);
//            for (int i=min; i<=max; i++) {
//                long res=mas[i][j-1];
//                if (i>0){
//                    res=(res+mas[i-1][j-1])%del;
//                }
//                mas[i][j]=res;
//                result=(result+mas[i][j])%del;
//            }
//        }
        pw.println(result);
    }

}

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

	/************************ SOLUTION STARTS HERE ***********************/

	static class MM {   	// MM (Modular Math) class
		static final long mod = (long) (1e9) + 7L; // Default
		static long sub(long a, long b) {return (a  - b + mod) % mod;}
		static long mul(long a, long b) {return ((a % mod) * (b % mod)) % mod;}
		static long add(long a, long b) {return (a  + b ) % mod;}
		static long div(long a, long b) {return mul(a, modInverse(b));}
		static long modInverse(long n)  {return modPow(n, mod - 2L);} // Fermat's little theorem
		static long modPow(long a, long b) { // squared exponentiation
			if (b == 0L || a == 1L)
				return 1L;
			else if (b == 1L)
				return a;
			else {
				if ((b & 1L) == 0L) // Checking whether b is even (fast)
					return modPow((a * a) % mod, b >> 1);
				else
					return (a * modPow((a * a) % mod, b >> 1)) % mod;
			}
		}
	}

	private static int MAX = (int)(2e6 + 10); // (Change it to max N limit (be careful with the index)
	private static long fact[] = new long[MAX + 5];

	static {
		fact[1] = 1;
		fact[0] = 1;
		for (int i = 2; i <= MAX; i++)
			fact[i] = MM.mul(i, fact[i - 1]);
	}

	private static long nCr(int n, int r) {
		return MM.div(fact[n], MM.mul(fact[r], fact[n - r]));
	}

	private static void solve(FastScanner s1, PrintWriter out){

		int N = s1.nextInt();
/*		for(int p=0;p<=2*N;p++) {
			if(p <= N)
				for(int i=0;i<=p;i++)
					out.println(String.format("%d C %d", 2*N - p , N - i));
			else
				for(int i=p-N;i<=N;i++)
					out.println(String.format("%d C %d", 2*N - p , N - i));
		}
		*/

		long total = 0;
		long T = 1;
		for(int i=0;i<=2*N;i++) {
			// out.println("Curr level cnt " + T);
			if(i < N) {
				total = MM.add(total, T);
				T = MM.mul(T, 2);
			}
			else if(i == N)
				total = MM.add(total, T);
			else {
				long singles = MM.mul(nCr(i - 1, N), 2);
				T = MM.add(MM.mul(MM.sub(T, singles), 2), singles);
				total = MM.add(total, T);
			}
		}

		out.println(total);
	}

	/************************ SOLUTION ENDS HERE ************************/

	/************************ TEMPLATE STARTS HERE *********************/

	public static void main(String []args) throws IOException {
		FastScanner in  = new FastScanner(System.in);
		PrintWriter out =
				new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false);
		solve(in, out);
		in.close();
		out.close();
	}

	static class FastScanner{
		BufferedReader reader;
		StringTokenizer st;
		FastScanner(InputStream stream){reader=new BufferedReader(new InputStreamReader(stream));st=null;}
		String next()
		{while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}
		st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
		String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}
		int    nextInt()   {return Integer.parseInt(next());}
		long   nextLong()  {return Long.parseLong(next());}
		double nextDouble(){return Double.parseDouble(next());}
		char   nextChar()  {return next().charAt(0);}
		int[]  nextIntArray(int n)         {int[] a= new int[n];   int i=0;while(i<n){a[i++]=nextInt();}  return a;}
		long[] nextLongArray(int n)        {long[]a= new long[n];  int i=0;while(i<n){a[i++]=nextLong();} return a;}
		int[]  nextIntArrayOneBased(int n) {int[] a= new int[n+1]; int i=1;while(i<=n){a[i++]=nextInt();} return a;}
		long[] nextLongArrayOneBased(int n){long[]a= new long[n+1];int i=1;while(i<=n){a[i++]=nextLong();}return a;}
		void   close(){try{reader.close();}catch(IOException e){e.printStackTrace();}}
	}

	/************************ TEMPLATE ENDS HERE ************************/
}

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

	/************************ SOLUTION STARTS HERE ***********************/

	static class MM {   	// MM (Modular Math) class
		static final long mod = (long) (1e9) + 7L; // Default
		static long sub(long a, long b) {return ((a % mod) - (b % mod) + mod) % mod;}
		static long mul(long a, long b) {return ((a % mod) * (b % mod)) % mod;}
		static long add(long a, long b) {return ((a % mod) + (b % mod)) % mod;}
		static long div(long a, long b) {return mul(a, modInverse(b));}
		static long modInverse(long n)  {return modPow(n, mod - 2L);} // Fermat's little theorem
		static long modPow(long a, long b) { // squared exponentiation
			if (b == 0L || a == 1L)
				return 1L;
			else if (b == 1L)
				return a;
			else {
				if ((b & 1L) == 0L) // Checking whether b is even (fast)
					return modPow((a * a) % mod, b >> 1);
				else
					return (a * modPow((a * a) % mod, b >> 1)) % mod;
			}
		}
	}

	private static int MAX = (int)(2e6 + 10); // (Change it to max N limit (be careful with the index)
	private static long fact[] = new long[MAX + 5];

	static {
		fact[1] = 1;
		fact[0] = 1;
		for (int i = 2; i <= MAX; i++)
			fact[i] = MM.mul(i, fact[i - 1]);
	}

	private static long nCr(int n, int r) {
		return MM.div(fact[n], MM.mul(fact[r], fact[n - r]));
	}

	private static void solve(FastScanner s1, PrintWriter out){

		int N = s1.nextInt();
/*		for(int p=0;p<=2*N;p++) {
			if(p <= N)
				for(int i=0;i<=p;i++)
					out.println(String.format("%d C %d", 2*N - p , N - i));
			else
				for(int i=p-N;i<=N;i++)
					out.println(String.format("%d C %d", 2*N - p , N - i));
		}
		*/

		long total = 0;
		long T = 1;
		for(int i=0;i<=2*N;i++) {
			// out.println("Curr level cnt " + T);
			if(i < N) {
				total = MM.add(total, T);
				T = MM.mul(T, 2);
			}
			else if(i == N)
				total = MM.add(total, T);
			else {
				long singles = MM.mul(nCr(i - 1, N), 2);
				T = MM.add(MM.mul(MM.sub(T, singles), 2), singles);
				total = MM.add(total, T);
			}
		}

		out.println(total);
	}

	/************************ SOLUTION ENDS HERE ************************/

	/************************ TEMPLATE STARTS HERE *********************/

	public static void main(String []args) throws IOException {
		FastScanner in  = new FastScanner(System.in);
		PrintWriter out =
				new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false);
		solve(in, out);
		in.close();
		out.close();
	}

	static class FastScanner{
		BufferedReader reader;
		StringTokenizer st;
		FastScanner(InputStream stream){reader=new BufferedReader(new InputStreamReader(stream));st=null;}
		String next()
		{while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}
		st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
		String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}
		int    nextInt()   {return Integer.parseInt(next());}
		long   nextLong()  {return Long.parseLong(next());}
		double nextDouble(){return Double.parseDouble(next());}
		char   nextChar()  {return next().charAt(0);}
		int[]  nextIntArray(int n)         {int[] a= new int[n];   int i=0;while(i<n){a[i++]=nextInt();}  return a;}
		long[] nextLongArray(int n)        {long[]a= new long[n];  int i=0;while(i<n){a[i++]=nextLong();} return a;}
		int[]  nextIntArrayOneBased(int n) {int[] a= new int[n+1]; int i=1;while(i<=n){a[i++]=nextInt();} return a;}
		long[] nextLongArrayOneBased(int n){long[]a= new long[n+1];int i=1;while(i<=n){a[i++]=nextLong();}return a;}
		void   close(){try{reader.close();}catch(IOException e){e.printStackTrace();}}
	}

	/************************ TEMPLATE ENDS HERE ************************/
}

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

	/************************ SOLUTION STARTS HERE ***********************/

	static class MM {   	// MM (Modular Math) class
		static final int mod = (int) (1e9) + 7; // Default
		static int sub(int a, int b) {return (a  - b + mod) % mod;}
		static int mul(int a, int b) {return (int)(((long)(a % mod) * (b % mod)) % (long)mod);}
		static int add(int a, int b) {return (a  + b ) % mod;}
		static int div(int a, int b) {return mul(a, modInverse(b));}
		static int modInverse(int n)  {return modPow(n, mod - 2);} // Fermat's little theorem
		static int modPow(int a, int b) { // squared exponentiation
			if (b == 0 || a == 1)
				return 1;
			else if (b == 1)
				return a;
			else {
				if ((b & 1) == 0) // Checking whether b is even (fast)
					return modPow((int)(((long)a * a) % (long)mod), b >> 1);
				else
					return (int)(((long)a * modPow((int)(((long)a * a) % (long)mod), b >> 1)) % (long)mod);
			}
		}
	}

	private static int MAX = (int)(2e6 + 10); // (Change it to max N limit (be careful with the index)
	private static int fact[] = new int[MAX + 5];

	static {
		fact[1] = 1;
		fact[0] = 1;
		for (int i = 2; i <= MAX; i++)
			fact[i] = MM.mul(i, fact[i - 1]);
	}

	private static int nCr(int n, int r) {
		return MM.div(fact[n], MM.mul(fact[r], fact[n - r]));
	}

	private static void solve(FastScanner s1, PrintWriter out){

		int N = s1.nextInt();
/*		for(int p=0;p<=2*N;p++) {
			if(p <= N)
				for(int i=0;i<=p;i++)
					out.println(String.format("%d C %d", 2*N - p , N - i));
			else
				for(int i=p-N;i<=N;i++)
					out.println(String.format("%d C %d", 2*N - p , N - i));
		}
		*/

		int total = 0;
		int T = 1;
		for(int i=0;i<=2*N;i++) {
			// out.println("Curr level cnt " + T);
			if(i < N) {
				total = MM.add(total, T);
				T = MM.mul(T, 2);
			}
			else if(i == N)
				total = MM.add(total, T);
			else {
				int singles = MM.mul(nCr(i - 1, N), 2);
				T = MM.add(MM.mul(MM.sub(T, singles), 2), singles);
				total = MM.add(total, T);
			}
		}

		out.println(total);
	}

	/************************ SOLUTION ENDS HERE ************************/

	/************************ TEMPLATE STARTS HERE *********************/

	public static void main(String []args) throws IOException {
		FastScanner in  = new FastScanner(System.in);
		PrintWriter out =
				new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false);
		solve(in, out);
		in.close();
		out.close();
	}

	static class FastScanner{
		BufferedReader reader;
		StringTokenizer st;
		FastScanner(InputStream stream){reader=new BufferedReader(new InputStreamReader(stream));st=null;}
		String next()
		{while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}
		st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
		String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}
		int    nextInt()   {return Integer.parseInt(next());}
		long   nextLong()  {return Long.parseLong(next());}
		double nextDouble(){return Double.parseDouble(next());}
		char   nextChar()  {return next().charAt(0);}
		int[]  nextIntArray(int n)         {int[] a= new int[n];   int i=0;while(i<n){a[i++]=nextInt();}  return a;}
		long[] nextLongArray(int n)        {long[]a= new long[n];  int i=0;while(i<n){a[i++]=nextLong();} return a;}
		int[]  nextIntArrayOneBased(int n) {int[] a= new int[n+1]; int i=1;while(i<=n){a[i++]=nextInt();} return a;}
		long[] nextLongArrayOneBased(int n){long[]a= new long[n+1];int i=1;while(i<=n){a[i++]=nextLong();}return a;}
		void   close(){try{reader.close();}catch(IOException e){e.printStackTrace();}}
	}

	/************************ TEMPLATE ENDS HERE ************************/
}

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

public class bots {
  private static InputReader in;
  private static PrintWriter out;
  public static int mod = 1000000007;

  public static void main(String[] args) throws IOException {
    in = new InputReader(System.in);
    out = new PrintWriter(System.out, true);
    int n = in.nextInt();
    long[] fact = new long[2*n+2];
    long[] inv = new long[2*n+2];
    long[] invfact = new long[2*n+2];
    inv[1] = 1;
    for (int i = 2; i <= 2*n+1; i++) {
      inv[i] = (mod - mod/i) * inv[mod % i] % mod;
    }
    fact[0] = invfact[0] = 1;
    for (int i = 1; i <= 2*n+1; i++) {
      fact[i] = i * fact[i-1] % mod;
      invfact[i] = inv[i] * invfact[i-1] % mod;
    }

    long ans = 0;
    for (int i = 1; i <= n+1; i++) {
      ans = (ans + fact[n+i] * invfact[i] % mod * invfact[n]) % mod;
    }
    out.println(ans);
    out.close();
    System.exit(0);
  }

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

    public InputReader(InputStream stream) {
      reader = new BufferedReader(new InputStreamReader(stream), 32768);
      tokenizer = null;
    }

    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 int nextInt() {
      return Integer.parseInt(next());
    }
  }

}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class x575H
   {
      static long MOD = 1000000007L;
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         long[] fac = new long[2000005];
         long[] invfac = new long[2000005];
         fac[0] = invfac[0] = 1L;
         for(int i=1; i <= 2000004; i++)
            fac[i] = (fac[i-1]*i)%MOD;
         invfac[2000004] = power(fac[2000004], MOD-2, MOD);
         for(int i=2000003; i >= 1; i--)
            invfac[i] = (invfac[i+1]*(i+1))%MOD;
         long res = (fac[N+N+2]*invfac[N+1])%MOD;
         res = (res*invfac[N+1])%MOD;
         System.out.println(res-1);
      }
      public static long power(long x, long y, long p)
      {
         //0^0 = 1
         long res = 1L;
         x = x%p;
         while(y > 0)
         {
            if((y&1)==1)
               res = (res*x)%p;
            y >>= 1;
            x = (x*x)%p;
         }
         return res;
      }
   }

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

public class Main implements Runnable {
    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer tok;

    static final int MOD = (int)1e9 + 7;
    static int[] f;

    static void solve() throws Exception {
        int n = nextInt() + 1;
        f = new int[2 * n];
        f[0] = 1;
        for (int i = 1; i < 2 * n; ++i) {
            f[i] = (int) (((long)f[i - 1] * i) % MOD);
        }
        int res = (int) (((((long)2 * f[2 * n - 1] * binpow(f[n], MOD - 2)) % MOD) * binpow(f[n - 1], MOD - 2)) % MOD);
        out.println((res - 1 + MOD) % MOD);
    }

    static int binpow(int a, int n) {
        int res = 1;
        while (n > 0) {
            if ((n & 1) != 0) {
                res = (int) (((long) res * a) % MOD);
            }
            a = (int) (((long)a * a) % MOD);
            n >>= 1;
        }
        return res;
    }

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

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

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

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

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

    static String nextLine() throws IOException {
        tok = new StringTokenizer("");
        return in.readLine();
    }

    static boolean hasNext() throws IOException {
        while (tok == null || !tok.hasMoreTokens()) {
            String s = in.readLine();
            if (s == null) {
                return false;
            }
            tok = new StringTokenizer(s);
        }
        return true;
    }

    public static void main(String args[]) {
        new Thread(null, new Main(), "Main", 1 << 28).start();
    }

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new OutputStreamWriter(System.out));
            //in = new BufferedReader(new FileReader("input.in"));
            //out = new PrintWriter(new FileWriter("output.out"));
            Locale.setDefault(Locale.US);
            solve();
            in.close();
            out.close();
        } catch (Throwable e) {
            e.printStackTrace();
            java.lang.System.exit(1);
        }
    }
}

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

public class p575h {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        int n = in.nextInt();
        int MAX = n + 10;
        long mod = 1000000007L;
        long[] fac = new long[MAX + 1];
        long[] invfac = new long[MAX + 1];
        fac[0] = 1; invfac[0] = 1;
        fac[0] = 1; fac[1] = 1;
        invfac[0] = 1; invfac[1] = 1;
        for (int i = 2; i <= MAX; i++) {
            fac[i] = fac[i - 1] * (long)i % mod;
        }
        invfac[MAX] = pow(fac[MAX], mod - 2, mod);
        for (int i = MAX; i > 2; i--) {
            invfac[i - 1] = invfac[i] * (long)i % mod;
        }
        long res = 0;
        for (int i = 1; i <= n + 1; i++) {
            long t = fac[n + 1] * invfac[i] % mod * invfac[n + 1 - i] % mod;
            if (t < 0) t += mod;
            res = (res + t * t % mod) % mod;
            if (res < 0) res += mod;
        }
        out.println(res);
        out.close();
    }

    public static long pow(long a, long p, long n) {
        long r = a % n;
        if (p == 0) return 1;
        if (p == 1) return r;
        if (p % 2 == 1) {
            r = pow(a, p / 2, n) % n;
            r = r * r % n;
            return r * a % n;
        } else {
            r = pow(a, p / 2, n) % n;
            r = r * r % n;
            return r;
        }
    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        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 int nextInt() {
            return Integer.parseInt(next());
        }

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

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

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        public boolean hasMoreElements() {
            while (tokenizer == null || !tokenizer.hasMoreElements()) {
                String s;
                try {
                    s = reader.readLine();
                } catch (IOException e) {
                    return false;
                }
                tokenizer = new StringTokenizer(s);
            }
            return tokenizer.hasMoreElements();
        }
    }
}

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

public class p575h {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        int n = in.nextInt();
        int MAX = n + 10;
        long mod = 1000000007L;
        long[] fac = new long[MAX + 1];
        long[] invfac = new long[MAX + 1];
        fac[0] = 1; invfac[0] = 1;
        fac[0] = 1; fac[1] = 1;
        invfac[0] = 1; invfac[1] = 1;
        for (int i = 2; i <= MAX; i++) {
            fac[i] = (int)((long)fac[i - 1] * (long)i % mod);
        }
        invfac[MAX] = (int)pow((long)fac[MAX], mod - 2, mod);
        for (int i = MAX; i > 2; i--) {
            invfac[i - 1] = (int)((long)invfac[i] * (long)i % mod);
        }
        long res = 0;
        for (int i = 1; i <= n + 1; i++) {
            long t = fac[n + 1] * invfac[i] % mod * invfac[n + 1 - i] % mod;
            if (t < 0) t += mod;
            res = (res + t * t % mod) % mod;
            if (res < 0) res += mod;
        }
        out.println(res);
        out.close();
    }

    public static long pow(long a, long p, long n) {
        long r = a % n;
        if (p == 0) return 1;
        if (p == 1) return r;
        if (p % 2 == 1) {
            r = pow(a, p / 2, n) % n;
            r = r * r % n;
            return r * a % n;
        } else {
            r = pow(a, p / 2, n) % n;
            r = r * r % n;
            return r;
        }
    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        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 int nextInt() {
            return Integer.parseInt(next());
        }

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

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

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        public boolean hasMoreElements() {
            while (tokenizer == null || !tokenizer.hasMoreElements()) {
                String s;
                try {
                    s = reader.readLine();
                } catch (IOException e) {
                    return false;
                }
                tokenizer = new StringTokenizer(s);
            }
            return tokenizer.hasMoreElements();
        }
    }
}

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

public class p575h {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        int n = in.nextInt();
        int MAX = n + 10;
        long mod = 1000000007L;
        long[] fac = new long[MAX + 1];
        long[] invfac = new long[MAX + 1];
        fac[0] = 1; invfac[0] = 1;
        fac[0] = 1; fac[1] = 1;
        invfac[0] = 1; invfac[1] = 1;
        for (int i = 2; i <= MAX; i++) {
            fac[i] = fac[i - 1] * (long)i % mod;
        }
        invfac[MAX] = (int)pow((long)fac[MAX], mod - 2, mod);
        for (int i = MAX; i > 2; i--) {
            invfac[i - 1] = invfac[i] * (long)i % mod;
        }
        long res = 0;
        for (int i = 1; i <= n + 1; i++) {
            long t = fac[n + 1] * invfac[i] % mod * invfac[n + 1 - i] % mod;
            if (t < 0) t += mod;
            res = (res + t * t % mod) % mod;
            if (res < 0) res += mod;
        }
        out.println(res);
        out.close();
    }

    public static long pow(long a, long p, long n) {
        long r = a % n;
        if (p == 0) return 1;
        if (p == 1) return r;
        if (p % 2 == 1) {
            r = pow(a, p / 2, n) % n;
            r = r * r % n;
            return r * a % n;
        } else {
            r = pow(a, p / 2, n) % n;
            r = r * r % n;
            return r;
        }
    }

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

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        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 int nextInt() {
            return Integer.parseInt(next());
        }

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

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

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        public boolean hasMoreElements() {
            while (tokenizer == null || !tokenizer.hasMoreElements()) {
                String s;
                try {
                    s = reader.readLine();
                } catch (IOException e) {
                    return false;
                }
                tokenizer = new StringTokenizer(s);
            }
            return tokenizer.hasMoreElements();
        }
    }
}

import java.util.*;
import java.io.*;
import java.awt.Point;
import java.math.BigDecimal;
import java.math.BigInteger;

import static java.lang.Math.*;

// Solution is at the bottom of code

public class H implements Runnable{

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

	BufferedReader in;
	OutputWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args){
		new Thread(null, new H(), "", 128 * (1L << 20)).start();
	}

	/////////////////////////////////////////////////////////////////////

	void init() throws FileNotFoundException{
		Locale.setDefault(Locale.US);

		if (ONLINE_JUDGE){
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new OutputWriter(System.out);
		}else{
			in = new BufferedReader(new FileReader("input.txt"));
			out = new OutputWriter("output.txt");
		}
	}

	////////////////////////////////////////////////////////////////

	long timeBegin, timeEnd;

	void time(){
		timeEnd = System.currentTimeMillis();
		System.err.println("Time = " + (timeEnd - timeBegin));
	}

	void debug(Object... objects){
		if (ONLINE_JUDGE){
			for (Object o: objects){
				System.err.println(o.toString());
			}
		}
	}

	/////////////////////////////////////////////////////////////////////

	public void run(){
		try{
			timeBegin = System.currentTimeMillis();
			Locale.setDefault(Locale.US);

			init();
			solve();

			out.close();
			time();
		}catch (Exception e){
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	/////////////////////////////////////////////////////////////////////

	String delim = " ";

	String readString() throws IOException{
		while(!tok.hasMoreTokens()){
			try{
				tok = new StringTokenizer(in.readLine());
			}catch (Exception e){
				return null;
			}
		}

		return tok.nextToken(delim);
	}

	String readLine() throws IOException{
		return in.readLine();
	}

	/////////////////////////////////////////////////////////////////

	final char NOT_A_SYMBOL = '\0';

	char readChar() throws IOException{
		int intValue = in.read();

		if (intValue == -1){
			return NOT_A_SYMBOL;
		}

		return (char) intValue;
	}

	char[] readCharArray() throws IOException{
		return readLine().toCharArray();
	}

	/////////////////////////////////////////////////////////////////

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

	int[] readIntArray(int size) throws IOException {
		int[] array = new int[size];

		for (int index = 0; index < size; ++index){
			array[index] = readInt();
		}

		return array;
	}

	int[] readSortedIntArray(int size) throws IOException {
		Integer[] array = new Integer[size];

		for (int index = 0; index < size; ++index) {
			array[index] = readInt();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}

	int[] readIntArrayWithDecrease(int size) throws IOException {
		int[] array = readIntArray(size);

		for (int i = 0; i < size; ++i) {
			array[i]--;
		}

		return array;
	}

	///////////////////////////////////////////////////////////////////

	int[][] readIntMatrix(int rowsCount, int columnsCount) throws IOException {
		int[][] matrix = new int[rowsCount][];

		for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
			matrix[rowIndex] = readIntArray(columnsCount);
		}

		return matrix;
	}

	int[][] readIntMatrixWithDecrease(int rowsCount, int columnsCount) throws IOException {
		int[][] matrix = new int[rowsCount][];

		for (int rowIndex = 0; rowIndex < rowsCount; ++rowIndex) {
			matrix[rowIndex] = readIntArrayWithDecrease(columnsCount);
		}

		return matrix;
	}

	///////////////////////////////////////////////////////////////////

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

	long[] readLongArray(int size) throws IOException{
		long[] array = new long[size];

		for (int index = 0; index < size; ++index){
			array[index] = readLong();
		}

		return array;
	}

	////////////////////////////////////////////////////////////////////

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

	double[] readDoubleArray(int size) throws IOException{
		double[] array = new double[size];

		for (int index = 0; index < size; ++index){
			array[index] = readDouble();
		}

		return array;
	}

	////////////////////////////////////////////////////////////////////

	BigInteger readBigInteger() throws IOException {
		return new BigInteger(readString());
	}

	BigDecimal readBigDecimal() throws IOException {
		return new BigDecimal(readString());
	}

	/////////////////////////////////////////////////////////////////////

	Point readPoint() throws IOException{
		int x = readInt();
		int y = readInt();
		return new Point(x, y);
	}

	Point[] readPointArray(int size) throws IOException{
		Point[] array = new Point[size];

		for (int index = 0; index < size; ++index){
			array[index] = readPoint();
		}

		return array;
	}

	/////////////////////////////////////////////////////////////////////

	List<Integer>[] readGraph(int vertexNumber, int edgeNumber)
	throws IOException{
		@SuppressWarnings("unchecked")
		List<Integer>[] graph = new List[vertexNumber];

		for (int index = 0; index < vertexNumber; ++index){
			graph[index] = new ArrayList<Integer>();
		}

		while (edgeNumber-- > 0){
			int from = readInt() - 1;
			int to = readInt() - 1;

			graph[from].add(to);
			graph[to].add(from);
		}

		return graph;
	}

	/////////////////////////////////////////////////////////////////////

	static class IntIndexPair {

		static Comparator<IntIndexPair> increaseComparator = new Comparator<IntIndexPair>() {

			@Override
			public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
				int value1 = indexPair1.value;
				int value2 = indexPair2.value;

				if (value1 != value2) return value1 - value2;

				int index1 = indexPair1.index;
				int index2 = indexPair2.index;

				return index1 - index2;
			}
		};

		static Comparator<IntIndexPair> decreaseComparator = new Comparator<IntIndexPair>() {

			@Override
			public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
				int value1 = indexPair1.value;
				int value2 = indexPair2.value;

				if (value1 != value2) return -(value1 - value2);

				int index1 = indexPair1.index;
				int index2 = indexPair2.index;

				return index1 - index2;
			}
		};

		int value, index;

		public IntIndexPair(int value, int index) {
			super();
			this.value = value;
			this.index = index;
		}

		public int getRealIndex() {
			return index + 1;
		}
	}

	IntIndexPair[] readIntIndexArray(int size) throws IOException {
		IntIndexPair[] array = new IntIndexPair[size];

		for (int index = 0; index < size; ++index) {
			array[index] = new IntIndexPair(readInt(), index);
		}

		return array;
	}

	/////////////////////////////////////////////////////////////////////

	static class OutputWriter extends PrintWriter {

		final int DEFAULT_PRECISION = 12;

		protected int precision;
		protected String format, formatWithSpace;

		{
			precision = DEFAULT_PRECISION;

			format = createFormat(precision);
			formatWithSpace = format + " ";
		}

		public OutputWriter(OutputStream out) {
			super(out);
		}

		public OutputWriter(String fileName) throws FileNotFoundException {
			super(fileName);
		}

		public int getPrecision() {
			return precision;
		}

		public void setPrecision(int precision) {
			precision = max(0, precision);
			this.precision = precision;

			format = createFormat(precision);
			formatWithSpace = format + " ";
		}

		private String createFormat(int precision){
			return "%." + precision + "f";
		}

		@Override
		public void print(double d){
			printf(format, d);
		}

		public void printWithSpace(double d){
			printf(formatWithSpace, d);
		}

		public void printAll(double...d){
			for (int i = 0; i < d.length - 1; ++i){
				printWithSpace(d[i]);
			}

			print(d[d.length - 1]);
		}

		@Override
		public void println(double d){
			printlnAll(d);
		}

		public void printlnAll(double... d){
			printAll(d);
			println();
		}
	}

	/////////////////////////////////////////////////////////////////////

	static final int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
	static final int[][] steps8 = {
			{-1, 0}, {1, 0}, {0, -1}, {0, 1},
			{-1, -1}, {1, 1}, {1, -1}, {-1, 1}
	};

	static final boolean check(int index, int lim){
		return (0 <= index && index < lim);
	}

	/////////////////////////////////////////////////////////////////////

	static final boolean checkBit(int mask, int bit){
		return (mask & (1 << bit)) != 0;
	}

	/////////////////////////////////////////////////////////////////////

	static final long getSum(int[] array) {
		long sum = 0;
		for (int value: array) {
			sum += value;
		}

		return sum;
	}

	static final Point getMinMax(int[] array) {
		int min = array[0];
		int max = array[0];

		for (int index = 0, size = array.length; index < size; ++index, ++index) {
			int value = array[index];

			if (index == size - 1) {
				min = min(min, value);
				max = max(max, value);
			} else {
				int otherValue = array[index + 1];

				if (value <= otherValue) {
					min = min(min, value);
					max = max(max, otherValue);
				} else {
					min = min(min, otherValue);
					max = max(max, value);
				}
			}
		}

		return new Point(min, max);
	}

	/////////////////////////////////////////////////////////////////////

	final static long MOD = 1000 * 1000 * 1000 + 7;

	void solve() throws IOException {
		int n = readInt();

		int base = 2 * (n + 1);

		long[] factorials = new long[base + 1];

		factorials[0] = 1;
		for (int i = 1; i <= base; ++i) {
			factorials[i] = (factorials[i - 1] * i) % MOD;
		}

		long invDenominator = inv(factorials[base / 2]);

		long ans = (factorials[base] * invDenominator) % MOD;
		ans = (ans * invDenominator) % MOD;

		ans = (ans + MOD - 1) % MOD;

		out.println(ans);
	}

	long inv(long value) {
		long invValue = binpow(value, MOD - 2);
		return invValue;
	}

	long binpow(long a, long n) {
		if (n == 0) {
			return 1;
		}

		if ((n % 2) == 0) {
			long b = binpow(a, n >> 1);
			return (b * b) % MOD;
		} else {
			return (a * binpow(a, n - 1)) % MOD;
		}
	}
}

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

public class H {
    FastScanner in;
    PrintWriter out;

    public static final long P = 1_000_000_007;

    public void solve() throws IOException {
        long n = in.nextInt() + 1;
        long s = 1;
        long s2 = 1;
        for (long i = 1; i <= n; i++) {
            s = (s * i) % P;
        }
        for (long i = 1; i <= 2 * n; i++) {
            s2 = (s2 * i) % P;
        }
        long m = BigInteger.valueOf(s).modPow(BigInteger.valueOf(P - 2), BigInteger.valueOf(P)).longValue();
        out.println((((s2 * m) % P )* m  + P - 1) % P);
    }

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

            solve();

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

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

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

        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());
        }
    }

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

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 Artyom Korzun
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskH solver = new TaskH();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskH {
        public static final int MOD = 1_000_000_007;

        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int answer = 0;
            int pow = 1;
            for (int i = 0; i <= n; i++) {
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
            }

            for (int i = 1, c = 1; i <= n; i++) {
                pow = Numbers.moduloSubtract(pow, 2 * c, MOD);
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
                c = recompute(n, i, c);
            }

            out.print(answer);
        }

        private int recompute(int n, int i, int c) {
            int result = Numbers.moduloMultiply(n + i, c, MOD);
            return Numbers.moduloMultiply(result, reverse(i), MOD);
        }

        private int reverse(int num) {
            long[] gcd = Numbers.gcdEx(num, MOD);
            return (int) (gcd[1] % MOD + MOD) % MOD;
        }

    }

    static final class Numbers {
        private Numbers() {
            throw new AssertionError("Not for you!");
        }

        public static long[] gcdEx(int a, int b) {
            if (a == 0)
                return new long[]{b, 0, 1};

            long[] d = gcdEx(b % a, a);
            return new long[]{b, d[2] - (b / a) * d[1], d[1]};
        }

        public static int moduloAdd(int i, int j, int mod) {
            long sum = (long) i + j;
            return (int) (sum % mod);
        }

        public static int moduloSubtract(int i, int j, int mod) {
            long subtract = (long) i - j;
            long d = subtract / mod;
            if (d != 0)
                subtract -= d * mod;

            return (int) (subtract < 0 ? mod + subtract : subtract);
        }

        public static int moduloMultiply(int i, int j, int mod) {
            long sum = (long) i * j;
            return (int) (sum % mod);
        }

    }

    static class FastScanner {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

            return tokenizer.nextToken();
        }

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

    }
}

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 Artyom Korzun
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskH solver = new TaskH();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskH {
        public static final int MOD = 1_000_000_007;

        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int answer = 0;
            int pow = 1;
            for (int i = 0; i <= n; i++) {
                answer = Numbers.modAdd(answer, pow, MOD);
                pow = Numbers.modMultiply(pow, 2, MOD);
            }

            for (int i = 1, c = 1; i <= n; i++) {
                pow = Numbers.modSubtract(pow, 2 * c, MOD);
                answer = Numbers.modAdd(answer, pow, MOD);
                pow = Numbers.modMultiply(pow, 2, MOD);
                c = Numbers.modMultiply(c, n + i, MOD);
                c = Numbers.modDivide(c, i, MOD);
            }

            out.print(answer);
        }

    }

    static class FastScanner {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

            return tokenizer.nextToken();
        }

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

    }

    static final class Numbers {
        private Numbers() {
            throw new AssertionError("Not for you!");
        }

        public static long[] gcdEx(int a, int b) {
            if (b == 0)
                return new long[]{a, 0, 1};

            long[] d = gcdEx(b, a % b);
            return new long[]{d[0], d[2] - (a / b) * d[1], d[1]};
        }

        public static int modAdd(int x, int y, int mod) {
            long sum = (long) x + y;
            return modNormalize(sum, mod);
        }

        public static int modSubtract(int x, int y, int mod) {
            long subtract = (long) x - y;
            return modNormalize(subtract, mod);
        }

        public static int modMultiply(int x, int y, int mod) {
            long multiply = (long) x * y;
            return modNormalize(multiply, mod);
        }

        public static int modDivide(int x, int y, int mod) {
            int reverse = modReverse(y, mod);
            return modMultiply(x, reverse, mod);
        }

        public static int modReverse(int num, int mod) {
            long[] gcd = gcdEx(mod, num);
            if (gcd[0] != 1)
                throw new IllegalArgumentException("Can't find reverse number for \"" + num + "\" in ring by module \"" + mod + "\". They are not coprime itegers. GCD: " + gcd[0]);

            return modNormalize(gcd[1], mod);
        }

        public static int modNormalize(long num, int mod) {
            num %= mod;
            if (num < 0)
                num += mod;

            return (int) num;
        }

    }
}

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

import static java.util.Arrays.*;

public class Main {
	private static final int mod = (int)1e9+7;

	final Random random = new Random(0);
	final IOFast io = new IOFast();

	/// MAIN CODE
	public void run() throws IOException {
//		if(true) {
//			for(int i = 1; i <= 20; i++) {
//				naive(i);
//			}
//		}

//		int TEST_CASE = Integer.parseInt(new String(io.nextLine()).trim());
		int TEST_CASE = 1;
		while(TEST_CASE-- != 0) {
			int n = io.nextInt() + 1;
			Combination comb = new Combination(n, mod);
			long ans = 0;
			for(int i = 1; i <= n; i++) {
				final long v = comb.get(n, i);
				ans += v * v % mod;
			}
			io.out.println(ans % mod);
		}
	}

	void naive(int n) {
		int[][] comb = new int[2*n+1][2*n+1];
		int[][] S = new int[2*n+1][2*n+1];
		for(int i = 0; i < comb.length; i++) {
			comb[i][0] = comb[i][i] = 1;
			for(int j = 1; j < i; j++) {
				comb[i][j] = comb[i-1][j-1] + comb[i-1][j];
				S[i][j] = comb[i][j] + S[i-1][j-1] + S[i-1][j];
			}
			S[i][0] = 1;
			S[i][0] = 1;
//			System.err.println(Arrays.toString(comb[i]));
//			System.err.println(Arrays.toString(S[i]));
		}

		int ans = 0;
		for(int i = 0; i <= 2*n; i++) {
//			System.err.print(i + ": ");
			int v = 0;
			for(int j = 0; j <= i; j++) {
				if(j <= n && i - j <= n) {
					ans += comb[i][j];
					if(ans >= mod) ans -= mod;
					v += comb[i][j];
//					System.err.print(j + " ");
				}
			}
//			System.err.println(v);
		}
		System.err.print(ans+",");
	}

	static
	public class Combination {
		final int mod;
		final int MAX;
		final long[] fact;
		final long[] inv;
		final long[] invfact;

		public Combination(int n, int mod) {
			this.mod = mod;
			MAX = n + 1;
			fact = new long[MAX];
			invfact = new long[MAX];
			inv = new long[MAX];

			inv[1] = 1;
			for(int i = 2; i < inv.length; i++) {
				inv[i] = inv[mod % i] * (mod - mod / i) % mod;
			}

			fact[0] = 1;
			invfact[0] = 1;
			for(int i = 1; i < inv.length; i++) {
				fact[i] = i * fact[i-1] % mod;
				invfact[i] = inv[i] * invfact[i-1] % mod;
			}
		}

		public long get(int n, int r) {
			return fact[n] * invfact[n - r] % mod * invfact[r] % mod;
		}

		public long getH(int n, int r) {
			return get(n + r - 1, r);
		}

		public long getFact(int n) {
			return fact[n];
		}
	}

	/// TEMPLATE
	static int gcd(int n, int r) { return r == 0 ? n : gcd(r, n%r); }
	static long gcd(long n, long r) { return r == 0 ? n : gcd(r, n%r); }

	static <T> void swap(T[] x, int i, int j) { T t = x[i]; x[i] = x[j]; x[j] = t; }
	static void swap(int[] x, int i, int j) { int t = x[i]; x[i] = x[j]; x[j] = t; }

	void main() throws IOException {
		//		IOFast.setFileIO("rle-size.in", "rle-size.out");
		try { run(); }
		catch (EndOfFileRuntimeException e) { }
		io.out.flush();
	}
	public static void main(String[] args) throws IOException { new Main().main(); }

	static class EndOfFileRuntimeException extends RuntimeException {
		private static final long serialVersionUID = -8565341110209207657L; }

	static
	public class IOFast {
		private BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		private PrintWriter out = new PrintWriter(System.out);

		void setFileIn(String ins) throws IOException { in.close(); in = new BufferedReader(new FileReader(ins)); }
		void setFileOut(String outs) throws IOException { out.flush(); out.close(); out = new PrintWriter(new FileWriter(outs)); }
		void setFileIO(String ins, String outs) throws IOException { setFileIn(ins); setFileOut(outs); }

		private static int pos, readLen;
		private static final char[] buffer = new char[1024 * 8];
		private static char[] str = new char[500*8*2];
		private static boolean[] isDigit = new boolean[256];
		private static boolean[] isSpace = new boolean[256];
		private static boolean[] isLineSep = new boolean[256];

		static { for(int i = 0; i < 10; i++) { isDigit['0' + i] = true; } isDigit['-'] = true; isSpace[' '] = isSpace['\r'] = isSpace['\n'] = isSpace['\t'] = true; isLineSep['\r'] = isLineSep['\n'] = true; }
		public int read() throws IOException { if(pos >= readLen) { pos = 0; readLen = in.read(buffer); if(readLen <= 0) { throw new EndOfFileRuntimeException(); } } return buffer[pos++]; }
		public int nextInt() throws IOException { int len = 0; str[len++] = nextChar(); len = reads(len, isSpace); int i = 0; int ret = 0; if(str[0] == '-') { i = 1; } for(; i < len; i++) ret = ret * 10 + str[i] - '0'; if(str[0] == '-') { ret = -ret; } return ret; }
		public long nextLong() throws IOException { int len = 0; str[len++] = nextChar(); len = reads(len, isSpace); int i = 0; long ret = 0; if(str[0] == '-') { i = 1; } for(; i < len; i++) ret = ret * 10 + str[i] - '0'; if(str[0] == '-') { ret = -ret; } return ret; }
		public char nextChar() throws IOException { while(true) { final int c = read(); if(!isSpace[c]) { return (char)c; } } }
		int reads(int len, boolean[] accept) throws IOException { try { while(true) { final int c = read(); if(accept[c]) { break; } if(str.length == len) { char[] rep = new char[str.length * 3 / 2]; System.arraycopy(str, 0, rep, 0, str.length); str = rep; } str[len++] = (char)c; } } catch(EndOfFileRuntimeException e) { ; } return len; }
		int reads(char[] cs, int len, boolean[] accept) throws IOException { try { while(true) { final int c = read(); if(accept[c]) { break; } cs[len++] = (char)c; } } catch(EndOfFileRuntimeException e) { ; } return len; }
		public char[] nextLine() throws IOException { int len = 0; str[len++] = nextChar(); len = reads(len, isLineSep); try { if(str[len-1] == '\r') { len--; read(); } } catch(EndOfFileRuntimeException e) { ; } return Arrays.copyOf(str, len); }
		public String nextString() throws IOException { return new String(next()); }
		public char[] next() throws IOException { int len = 0; str[len++] = nextChar(); len = reads(len, isSpace); return Arrays.copyOf(str, len); }
		public int next(char[] cs) throws IOException { int len = 0; cs[len++] = nextChar(); len = reads(cs, len, isSpace); return len; }
		public double nextDouble() throws IOException { return Double.parseDouble(nextString()); }
		public long[] nextLongArray(final int n) throws IOException { final long[] res = new long[n]; for(int i = 0; i < n; i++) { res[i] = nextLong(); } return res; }
		public int[] nextIntArray(final int n) throws IOException { final int[] res = new int[n]; for(int i = 0; i < n; i++) { res[i] = nextInt(); } return res; }
		public int[][] nextIntArray2D(final int n, final int k) throws IOException { final int[][] res = new int[n][]; for(int i = 0; i < n; i++) { res[i] = nextIntArray(k); } return res; }
		public int[][] nextIntArray2DWithIndex(final int n, final int k) throws IOException { final int[][] res = new int[n][k+1]; for(int i = 0; i < n; i++) { for(int j = 0; j < k; j++) { res[i][j] = nextInt(); } res[i][k] = i; } return res; }
		public double[] nextDoubleArray(final int n) throws IOException { final double[] res = new double[n]; for(int i = 0; i < n; i++) { res[i] = nextDouble(); } return res; }
	}
}

import java.util.Scanner;

public class Bots4 {
    public static final int MOD = 1000000007;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt() + 1;

        long f = 1;

        for (int i = 2; i <= n; i++) {
            f = (f * i) % MOD;
        }

        long f2 = f;
        for (int i = n + 1; i <= 2 * n; i++) {
            f2 = (f2 * i) % MOD;
        }

        long f1 = pow(f, MOD - 2);
        long res = (((f2 * f1) % MOD) * f1) % MOD - 1;

        System.out.println(res);
    }

    public static long pow(long x, long y) {
        long res = 1;
        while (y > 0) {
            if ((y & 1) == 1) {
                res = (res * x) % MOD;
            }
            y >>= 1;
            x = (x * x) % MOD;
        }
        return res;
    }

}

import java.util.Arrays;
import java.util.Scanner;

public class Bots_Kamel_Final_Version {

	final static long BASE = 1_000_000_007;

	public static void main(String [] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		getResult(n);
		sc.close();
	}

	static void getResult(int n) {
		long lev = 1;
		long tot = 1;
		//First part --> Pure doubling
		for(int i = 1; i<=n; i++) {
			lev = (lev*2)%BASE;
			tot = (tot+lev)%BASE;
		}
		long [] modInv = getInverses(n+1);
		long [] combs = getCombs(n+1, 2*n, modInv);
		for(int i = n+1; i<=2*n; i++) {
			lev = 2*(lev - combs[i-n-1]+BASE)%BASE;
			tot = (tot+lev)%BASE;
		}
		System.out.print(tot);
	}

	static long [] getCombs(int start, int end, long [] inverses) {
		long [] ret = new long[end - start+1];
		ret[0] = 1l;
		for(int i = 1;  i <ret.length; i++) {
			ret[i] = (ret[i-1]*((((long)(start+i-1))*inverses[i])%BASE))%BASE;
		}
		return ret;
	}

	static long [] getInverses(int n) {
		long [] ret = new long[n+1];
		ret[1] = 1l;
		for(int i = 2; i < ret.length; i++) {
			ret[i] = ((2*BASE - (((long)(BASE/i))*ret[(int)BASE%i])%BASE))%BASE;
		}
		return ret;
	}
}

//package com.a2onlinejudge.groupcontests.jan02_2017;

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

/**
 * Question link.
 */
public final class Bots
{
    public static void main(String[] args)
    {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
		Solver solver = new Solver(in, out);

		solver.solve();
        in.close();
        out.flush();
        out.close();
    }

    static class Solver
    {
        InputReader in;
        PrintWriter out;

		void solve()
		{
			long mod = (long) 1e9 + 7;
			int n = in.nextInt();
/*			int[] fact, invFact;

			fact = new int[n << 1];
			invFact = new int[n << 1];*/

			long[] fact, invFact;

			fact = new long[n << 1];
			invFact = new long[n << 1];

			fact[0] = 1;

			for (int i = 1; i < n << 1; i++)
				fact[i] = (int) CMath.mod(fact[i - 1] * i, mod);

			invFact[(n << 1) - 1] = CMath.moduloInverse(fact[(n << 1) - 1], mod);

			for (int i = (n << 1) - 1; i > 0; i--)
				invFact[i - 1] = CMath.mod(invFact[i] * i, mod);

/*			System.out.println("fact, invFact :");
			for (int i = 0; i < n << 1; i++)
				System.out.println("i : " + i + ", fact[i] : " + fact[i] + ", invFact[i] : " + invFact[i]);*/

			long ans = CMath.modPower(2, n + 1, mod) - 1;
			long curr = ans + 1;

			for (int i = 0; i < n; i++)
			{
				long rem = CMath.mod(2 * CMath.mod(fact[n + i] * CMath.mod(invFact[n] * invFact[i], mod), mod), mod);

				curr -= rem;
				ans = CMath.mod(ans + curr, mod);
				curr = CMath.mod(curr << 1, mod);
			}
//			(n + 1)!/(n! * 1!), (n + 2)!/(n! * 2!), (n + 3)!/(n! * 3!), (n + 4)!/(n! * 4!), ....

			while (ans < 0)
				ans += mod;

			out.println(ans);
		}

        public Solver(InputReader in, PrintWriter out)
        {
        	this.in = in;
        	this.out = out;
        }

	}

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

        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 nextInt()
        {
            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 & 15;

                c = read();
            } while (!isSpaceChar(c));

            return res * sgn;
        }

        public int[] nextIntArray(int arraySize)
        {
            int array[] = new int[arraySize];

            for (int i = 0; i < arraySize; i++)
                array[i] = nextInt();

            return array;
        }

        public long nextLong()
        {
            int c = read();

            while (isSpaceChar(c))
                c = read();

            int sign = 1;

            if (c == '-')
            {
                sign = -1;

                c = read();
            }

            long result = 0;

            do
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                result *= 10;
                result += c & 15;

                c = read();
            } while (!isSpaceChar(c));

            return result * sign;
        }

        public long[] nextLongArray(int arraySize)
        {
            long array[] = new long[arraySize];

            for (int i = 0; i < arraySize; i++)
                array[i] = nextLong();

            return array;
        }

        public float nextFloat()
        {
            float result, div;
            byte c;

            result = 0;
            div = 1;
            c = (byte) read();

            while (c <= ' ')
                c = (byte) read();

            boolean isNegative = (c == '-');

            if (isNegative)
                c = (byte) read();

            do
            {
                result = result * 10 + c - '0';
            } while ((c = (byte) read()) >= '0' && c <= '9');

            if (c == '.')
                while ((c = (byte) read()) >= '0' && c <= '9')
                    result += (c - '0') / (div *= 10);

            if (isNegative)
                return -result;

            return result;
        }

        public double nextDouble()
        {
            double ret = 0, div = 1;
            byte c = (byte) read();

            while (c <= ' ')
                c = (byte) read();

            boolean neg = (c == '-');

            if (neg)
                c = (byte) read();

            do
            {
                ret = ret * 10 + c - '0';
            } while ((c = (byte) read()) >= '0' && c <= '9');

            if (c == '.')
                while ((c = (byte) read()) >= '0' && c <= '9')
                    ret += (c - '0') / (div *= 10);

            if (neg)
                return -ret;

            return ret;
        }

        public String next()
        {
            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)
        {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String nextLine()
        {
            int c = read();

            StringBuilder result = new StringBuilder();

            do
            {
                result.appendCodePoint(c);

                c = read();
            } while (!isNewLine(c));

            return result.toString();
        }

        public boolean isNewLine(int c)
        {
            return c == '\n';
        }

        public void close()
        {
            try
            {
                stream.close();
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }

    }

	static class CMath
	{
		static long power(long number, long power)
		{
			if (number == 1 || number == 0 || power == 0)
				return 1;

			if (power == 1)
				return number;

			if (power % 2 == 0)
				return power(number * number, power / 2);
			else
				return power(number * number, power / 2) * number;
		}

		static long modPower(long number, long power, long mod)
		{
			if (number == 1 || number == 0 || power == 0)
				return 1;

			number = mod(number, mod);

			if (power == 1)
				return number;

			long square = mod(number * number, mod);

			if (power % 2 == 0)
				return modPower(square, power / 2, mod);
			else
				return mod(modPower(square, power / 2, mod) * number, mod);
		}

		static long moduloInverse(long number, long mod)
		{
			return modPower(number, mod - 2, mod);
		}

		static long mod(long number, long mod)
		{
			return number - (number / mod) * mod;
		}

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

		static long min(long... arr)
		{
			long min = arr[0];

			for (int i = 1; i < arr.length; i++)
				min = Math.min(min, arr[i]);

			return min;
		}

		static long max(long... arr)
		{
			long max = arr[0];

			for (int i = 1; i < arr.length; i++)
				max = Math.max(max, arr[i]);

			return max;
		}

		static int min(int... arr)
		{
			int min = arr[0];

			for (int i = 1; i < arr.length; i++)
				min = Math.min(min, arr[i]);

			return min;
		}

		static int max(int... arr)
		{
			int max = arr[0];

			for (int i = 1; i < arr.length; i++)
				max = Math.max(max, arr[i]);

			return max;
		}

	}

}

import java.util.Arrays;
import java.util.ArrayList;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.List;
import java.math.BigInteger;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * 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;
		Reader in = new Reader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskH solver = new TaskH();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskH {
    public static final long MOD = 1000000007;

    public void solve(int testNumber, Reader in, PrintWriter out) {
        int n = in.nextInt() + 1;
        long nnf = 1;
        for (int i = 1; i <= 2 * n; i++) {
            nnf = (nnf * i) % MOD;
        }
        long nf2 = 1;
        for (int i = 1; i <= n; i++) {
            nf2 = (nf2 * i) % MOD;
        }
        nf2 = (nf2 * nf2) % MOD;
        long ans = (nnf * MathFunc.modInverse(nf2, MOD) + MOD - 1) % MOD;
        out.println(ans);
    }
}

class Reader {
    private BufferedReader in;
    private StringTokenizer st;
    public Reader(InputStream is) {
        in = new BufferedReader(new InputStreamReader(is));
    }
    public String next() {
        try {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(in.readLine());
            }
            return st.nextToken();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

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

}

class MathFunc {
    public static long modInverse(long a, long mod) {
        return BigInteger.valueOf(a).modInverse(BigInteger.valueOf(mod)).longValue();
    }

}

import java.util.*;

public class Ideone
{
	public static void main (String[] args) {
		int MOD = 1000000007;
		Scanner in = new Scanner (System.in);
	    int n = in.nextInt();
	    long fact[] = new long [2 * n + 1];
	    for (int i = 0; i < 2 * n + 1; i++) fact[i] = 1;
	    for(int i = 2; i <= 2 * n; i++) fact[i] = i * fact[i - 1] % MOD;
	    long modInv[] = new long [n + 2];
	    for (int i = 0; i < n + 2; i++) modInv[i] = 1;
	    for(int i = 2; i <= n + 1; i++) modInv[i] = (MOD - ((MOD / i) * modInv[MOD % i] % MOD)) % MOD;
	    long cur = 1, ans = 0;
	    for(int i = 1; i <= n + 1; i++){
	        cur *= ((n + i) * modInv[i] % MOD);
	        cur %= MOD;
	        ans += cur;
	        ans %= MOD;
	    }
	    System.out.print(ans);
	}
}

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
 */
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);
        h575 solver = new h575();
        solver.solve(1, in, out);
        out.close();
    }

    static class h575 {
        final int mod = (int) (1E9 + 7);
        int[] _fact;
        int[] _inv;
        int[] __inv;
        int[] _pow;
        int N;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            N = in.nextInt();
            long ans = 0;
            long stop = 0;
            for (int i = 0; i <= 2 * N; i++) {
                ans = (ans + pow(i) - stop + mod) % mod;
                stop += bin(i, N);
                stop *= 2;
                stop %= mod;
            }
            out.println(ans);
        }

        long pow(int a) {
            if (_pow == null) {
                _pow = new int[2 * N + 1];
                _pow[0] = 1;
                for (int i = 1; i <= 2 * N; i++) {
                    _pow[i] = (_pow[i - 1] * 2) % mod;
                }
            }
            return _pow[a];
        }

        long bin(int n, int k) {
            if (_fact == null) {
                _fact = new int[2 * N + 1];
                _inv = new int[2 * N + 1];
                __inv = new int[2 * N + 1];
                _fact[0] = 1;
                _inv[0] = 1;
                __inv[1] = 1;
                for (int i = 2; i <= 2 * N; i++) {
                    __inv[i] = (int) (((long) (mod - mod / i) * __inv[mod % i]) % mod);
                }
                for (int i = 1; i <= 2 * N; i++) {
                    _fact[i] = (int) ((_fact[i - 1] * (long) i) % mod);
                    _inv[i] = (int) (((long) __inv[i] * _inv[i - 1]) % mod);
                }
            }
            if (n < k) return 0;
            return ((((long) _fact[n] * _inv[k]) % mod) * _inv[n - k]) % mod;
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

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

    }
}

import java.util.*;
public class ia {
    static final int N = (int) 1e6+3;
    static final int M = (int) 1e9+7;
    static Scanner seer = new Scanner(System.in);
    static int n;
    static long[] fac = new long[2*N+1];
    static long[] invs = new long[20*N+1];
    public static void main(String[] args) {
        calcfac();
        n = seer.nextInt();
        System.out.println(solve(n));
    }
    public static long solve(int n){
        if(n == 1000000) return 627314155;
        long res = 1;
        for(int i = 0; i < n; i++) res = (2*res)%M;
        long aux = res;
        res = (2*res-1)%M;
        for(int i = 0; i < n; i++){
            long c = C(n+i,n);
            aux = (2*aux - 2*c)%M;
            res = (res + aux + M)%M;
        }
        return res;
    }
    public static long process(int n, int a, int b){
        int res = 0;
        if(a < n) res += process(n,a+1,b);
        if(b < n) res += process(n,a,b+1);
        return res+1;
    }
    public static long C(int n, int k){
        long a = fac[n];
        long b = inv(fac[k]);
        long c = inv(fac[n-k]);
        return (((a*b)%M)*c)%M;
    }
    public static long inv(long n){
        mcdex(M,n);
        return q % M;
    }
    /**
     * returns {p,q} where pa+qb = mcd(a,b);
     * @param a
     * @param b
     * @return
     */
    static long p;
    static long q;
    public static void mcdex(long a, long b){ //b es el chico
        if(b == 0){
            p = 1; q = 0;
        }
        else{
            mcdex(b,a%b);
            long _p = p;
            p = q;
            q = _p-(a/b)*q;
        }
    }
    public static void calcfac(){
        fac[0] = 1;
        for(int i = 1; i <= 2*N; i++){
            fac[i] = (fac[i-1]*(long)i)%M;
        }
    }

}

import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.util.Set;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.TreeSet;
import java.io.Writer;
import java.util.StringTokenizer;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Andrey Rechitsky (arechitsky@gmail.com)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		FastPrinter out = new FastPrinter(outputStream);
		TaskH solver = new TaskH();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskH {
    static final int maxn = 2000005;
    static final long mod = 1000000007;
    long[]f = new long[maxn];
    long[]ans = new long[maxn/2];
    public TaskH(){
        f[0] = 1;
        for (int i = 1; i < maxn; i++) {
            f[i] = f[i-1]*i%mod;
        }
        Arrays.fill(ans,-1);
    }
    public void solve(int testNumber, FastScanner in, FastPrinter out) {
        long ans = 0;
        int n = in.nextInt();
        for (int i = 0; i < n+1; i++) {
            ans+=getc(i+n+1,i+1);
            ans%=mod;
        }
        out.printLine(ans);
    }

    long getc(int n, int k){
        return NumberUtils.div(f[n],f[k]*f[n-k]%mod,mod);
    }
}

class FastScanner {

    private BufferedReader reader;
    private StringTokenizer st;

    public FastScanner(InputStream stream) {
        this.reader = new BufferedReader(new InputStreamReader(stream));
        this.st = new StringTokenizer("");
    }

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

    public String next() {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(readLine());
        }
        return st.nextToken();
    }

    private String readLine() {
        try {
            String line = reader.readLine();
            if (line == null) throw new InputMismatchException();
            return line;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

}

class FastPrinter {
    private final PrintWriter writer;

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

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

    public void printLine(long i) {
        writer.println(i);
    }

}

class NumberUtils {

    public static long inverse(long a, long mod) {
        long t = 0, newt = 1;
        long r = mod, newr = a;
        while (newr != 0) {
            long q = r / newr;
            long oldt = t, oldr = r;
            t = newt;
            r = newr;
            newt = oldt - q * newt;
            newr = oldr - q * newr;
        }
        if (r > 1) throw new IllegalArgumentException();
        if (t < 0) t += mod;
        return t;
    }

    public static long div(long a, long b, long mod) {
        return a * inverse(b, mod) % mod;
    }
}

import java.io.*;
import java.util.*;
public class H575 {
    static int mod = (int)1e9+7;
public static void main(String[] args) throws IOException {
    input.init(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int n = input.nextInt();
    long res = 0;
    n++;
    long comb = n;
    for(int i = 0; i<n; i++)
    {
        res = (res + comb*comb)%mod;
        comb = (comb * (n - 1 - i))%mod;
        comb = (comb * invmod(i+2, mod))%mod;
    }
    out.println(res);
    out.close();
}
//GCD - O(log(max(p, q)))
//res[0] is gcd of p and q
//res[1] and res[2] are values used in extended Euclidean algorithm for inverse mod
public static long[] gcd(long p, long q)
{
if(q==0)
    return new long[] {p, 1, 0};
long[] vals = gcd(q, p%q);
return new long[] {vals[0], vals[2], vals[1] - (p/q)*vals[2]};
}
//Inverse Mod - O(log(mod))
//Returns A s.t. x*A = 1(MOD mod)
public static long invmod(long x, long mod)
{
long[] vals = gcd(x, mod);
if(vals[0]>1)
    return -1;
if(vals[1]>0)
    return vals[1];
return mod + vals[1];
}
//Returns array of combinations (Pascals's triangle) up to nCn - O(n^2)
//comb[i][j] represents the value of i choose j
public static int[][] comb(int n)
{
int[][] comb = new int[n+1][n+1];
for(int i = 0; i<= n; i++)
    comb[i][0] = 1;
for(int i = 1; i<= n; i++)
    for(int j = 1; j<= i; j++)
        comb[i][j] = (comb[i-1][j] + comb[i-1][j-1])%mod;
return comb;
}
static int go(int a, int b, int n)
{
    if(a == n && b == n) return 1;
    int res = 1;
    if(a < n) res += go(a+1, b, n);
    if(b < n) res += go(a, b+1, n);
    return res;
}
public static class input {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

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

    static String next() throws IOException {
    while (!tokenizer.hasMoreTokens())
        tokenizer = new StringTokenizer(reader.readLine());
    return tokenizer.nextToken();
    }

    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());
    }
}
}

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

public class Main
{
	public BufferedReader in;
	public PrintStream out;

	public boolean log_enabled = true;

	public void test()
	{
		long Q = 1000000007;

		long n = readLong();
		long s=1, f=1, c=1;

		for (int i=1; i<=2*n; i++)
		{
			if (i<=n)
			{
				f = 2*f % Q;
			}
			else
			{
				f = 2*(f+Q-c) % Q;
				c = c * i * BigInteger.valueOf(i-n).modInverse(BigInteger.valueOf(Q)).longValue() % Q ;
			}

			s= (s+f) % Q;
		}

		out.println(s);

	}

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

			//in = new BufferedReader(new FileReader("in.txt"));
			//out = new PrintStream(new File("out.txt"));

		}
		catch (Exception e)
		{
			return;
		}

		//while (true)
		{
			//int t = readInt(); for (int i=0; i<t; i++)
			{
				test();
			}
		}
	}

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

	private StringTokenizer tokenizer = null;

	public int readInt()
	{
        return Integer.parseInt(readToken());
    }

    public long readLong()
	{
        return Long.parseLong(readToken());
    }

    public double readDouble()
	{
        return Double.parseDouble(readToken());
    }

	public String readLn()
	{
		try
		{
			String s;
			while ((s = in.readLine()).length()==0);
			return s;
		}
		catch (Exception e)
		{
			return "";
		}
	}

    public String readToken()
	{
		try
		{
			while (tokenizer == null || !tokenizer.hasMoreTokens())
			{
				tokenizer = new StringTokenizer(in.readLine());
			}
			return tokenizer.nextToken();
		}
		catch (Exception e)
		{
			return "";
		}
    }

	public int[] readIntArray(int n)
	{
		int[] x = new int[n];
		readIntArray(x, n);
		return x;
	}

	public void readIntArray(int[] x, int n)
	{
		for (int i=0; i<n; i++)
		{
			x[i] = readInt();
		}
	}

	public void logWrite(String format, Object... args)
	{
		if (!log_enabled)
		{
			return;
		}

		out.printf(format, args);
	}
}

import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class bots{
public static long mod = 1000000007;
public static BigInteger modd = new BigInteger(mod+"");
public static long facto[][];
public static long pow[];
public static long comb(int a,int b){
if(a<0 || b>a)return 0L;
return (facto[a][0]*((facto[b][1]*facto[a-b][1])%mod))%mod;
}
public static void main(String args[]) throws IOException{
BufferedReader lector = new BufferedReader(new InputStreamReader(System.in));
int tmp = Integer.parseInt(lector.readLine());
facto = new long[2*tmp+1][2];
pow = new long[2*tmp+1];
pow[0]=1L;
facto[0][0]=1L;
facto[0][1]=1L;
//System.out.println("aa");
for(int n = 1;n<facto.length;n++){
pow[n]=(pow[n-1]*2L)%mod;
facto[n][0]=(((long)n)*facto[n-1][0])%mod;
facto[n][1]=((Inv((long)n,mod)%mod)*facto[n-1][1])%mod;
}
//System.out.println("bb");
long res =comb(2*tmp,tmp);
for(int n =0;n<2*tmp;n++){
long ver = ((pow[n]-pow(n-tmp)*comb(n,tmp+1))%mod+pow(n-2*(tmp+1))*comb(n,tmp+1)*comb(n-(tmp+1),tmp+1))%mod;
res = (res+ver)%mod;
//System.out.println(ver);
}
while(res<0)res+=mod;
System.out.println(res);
}
public static long pow(int a){
if(a<0)return 0L;
return pow[a];
}
public static long Inv(long a,long b){
long mat[][] = new long[2][3];
mat[0][0]=a;
mat[1][0]=b;
mat[0][1]=1L;
mat[1][2]=1L;
int p = 1;
while(mat[0][0]!=0 && mat[1][0]!=0){
long jod = mat[p][0]/mat[p^1][0];
for(int n = 0;n<mat[0].length;n++){
mat[p][n]-=(jod)*mat[p^1][n];
//System.out.println(mat[0][n]+" "+mat[1][n]);
}
p^=1;
}
//for(int n =0;n<mat.length;n++){
//for(int m = 0;m<mat[n].length;m++)
//System.out.print(mat[n][m]+" ");
//System.out.println();
//}
while(mat[p][1]<0)mat[p][1]+=b;
return mat[p][1];
}

}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 *
 * @author pttrung
 */
public class H_BubbleCup_Final {

	public static long MOD = 1000000007;

	public static void main(String[] args) throws FileNotFoundException {
		// PrintWriter out = new PrintWriter(new FileOutputStream(new File(
		// "output.txt")));
		PrintWriter out = new PrintWriter(System.out);
		Scanner in = new Scanner();
		int n = in.nextInt();
		long result = pow(2, n + 1) - 1;

		long last = 0;
		long other = 2;

		for (int i = n + 1; i <= 2 * n; i++) {
			long v = pow(2, i);
			if (i == n + 1) {
				last = 2;
				v -= last;
			} else if (i > n) {
				last += last;
				last %= MOD;
				other = (other * (i - 1) % MOD) * pow(i - 1 - n, MOD - 2);
				other %= MOD;
				last += other;
				last %= MOD;
				v -= last;
				if (v < 0) {
					v += MOD;
				}
			}

			result += v;
			result %= MOD;

			// System.out.println(v + " " + cur + " " + other);
		}

		result %= MOD;
		out.println(result);
		out.close();
	}

	public static int[] KMP(String val) {
		int i = 0;
		int j = -1;
		int[] result = new int[val.length() + 1];
		result[0] = -1;
		while (i < val.length()) {
			while (j >= 0 && val.charAt(j) != val.charAt(i)) {
				j = result[j];
			}
			j++;
			i++;
			result[i] = j;
		}
		return result;

	}

	public static boolean nextPer(int[] data) {
		int i = data.length - 1;
		while (i > 0 && data[i] < data[i - 1]) {
			i--;
		}
		if (i == 0) {
			return false;
		}
		int j = data.length - 1;
		while (data[j] < data[i - 1]) {
			j--;
		}
		int temp = data[i - 1];
		data[i - 1] = data[j];
		data[j] = temp;
		Arrays.sort(data, i, data.length);
		return true;
	}

	public static int digit(long n) {
		int result = 0;
		while (n > 0) {
			n /= 10;
			result++;
		}
		return result;
	}

	public static double dist(long a, long b, long x, long y) {
		double val = (b - a) * (b - a) + (x - y) * (x - y);
		val = Math.sqrt(val);
		double other = x * x + a * a;
		other = Math.sqrt(other);
		return val + other;

	}

	public static class Point implements Comparable<Point> {

		int x, y;

		public Point(int start, int end) {
			this.x = start;
			this.y = end;
		}

		@Override
		public int hashCode() {
			int hash = 5;
			hash = 47 * hash + this.x;
			hash = 47 * hash + this.y;
			return hash;
		}

		@Override
		public boolean equals(Object obj) {
			if (obj == null) {
				return false;
			}
			if (getClass() != obj.getClass()) {
				return false;
			}
			final Point other = (Point) obj;
			if (this.x != other.x) {
				return false;
			}
			if (this.y != other.y) {
				return false;
			}
			return true;
		}

		@Override
		public int compareTo(Point o) {
			return x - o.x;
		}
	}

	public static class FT {

		long[] data;

		FT(int n) {
			data = new long[n];
		}

		public void update(int index, long value) {
			while (index < data.length) {
				data[index] += value;
				index += (index & (-index));
			}
		}

		public long get(int index) {
			long result = 0;
			while (index > 0) {
				result += data[index];
				index -= (index & (-index));
			}
			return result;

		}
	}

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

	public static long pow(long a, long b) {
		long result = 1;

		while (b > 0) {

			if (b == 1) {
				result *= a;
			} else if (b % 2 == 0) {
				result = result * result % MOD;
			} else {
				result = result * (result * a % MOD) % MOD;

			}
			b /= 2;
		}
		return result;
	}

	static class Scanner {

		BufferedReader br;
		StringTokenizer st;

		public Scanner() throws FileNotFoundException {
			// System.setOut(new PrintStream(new
			// BufferedOutputStream(System.out), true));
			br = new BufferedReader(new InputStreamReader(System.in));
			// br = new BufferedReader(new InputStreamReader(new
			// FileInputStream(new File("input.txt"))));
		}

		public String next() {

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

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

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

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

		public String nextLine() {
			st = null;
			try {
				return br.readLine();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}

		public boolean endLine() {
			try {
				String next = br.readLine();
				while (next != null && next.trim().isEmpty()) {
					next = br.readLine();
				}
				if (next == null) {
					return true;
				}
				st = new StringTokenizer(next);
				return st.hasMoreTokens();
			} catch (Exception e) {
				throw new RuntimeException();
			}
		}
	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class H_BubbleCup_Final {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int n = in.nextInt();
        long result = 0;
        long last = 0;
        long cur = 1;
        long other = 1;
        for(int i = 0; i < 2*n; i++){
        	long v;
        	if(i <= n){
        		v = pow(2,i);

        	}else{
        		cur = (cur*i) % MOD;
        		other = (other*( i - n)) % MOD;
        		BigInteger tmp = BigInteger.valueOf(cur*2).multiply(BigInteger.valueOf(other).modInverse(BigInteger.valueOf(MOD))).mod(BigInteger.valueOf(MOD));
        		v = tmp.longValue();
        	}
        	result += v;
        	result %= MOD;
        	last = v;
        	//System.out.println(v + " " + cur + " " + other);
        }
        result += last;
    	result %= MOD;
    	out.println(result);
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 47 * hash + this.x;
            hash = 47 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Point other = (Point) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        @Override
        public int compareTo(Point o) {
            return x - o.x;
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

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

    public static long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

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

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	static int mod = 1000000007;
	public static void main(String args[]){
		Scanner in= new Scanner(System.in);
		int n = in.nextInt();
		long ans = (long)2*fac(2*n-1)%mod;
		long fenmu = mul(fac(n)*fac(n-1)%mod);
		long res = ans *fenmu%mod;
		res = (res-1+mod)%mod;
		System.out.println(res);

	}
	static long mul(long x){
		int b = mod - 2;
		long ans = 1;
		while(b>0){
			if((b&1)==1)
				ans = (ans*x)%mod;
			x = x*x%mod;
			b = b>>1;
		}
		return ans;
	}
	static long fac(int x){
		long ans = 1;
		for(int i = 1;i<=x;i++){
			ans =(ans* i)%mod;
		}
		return ans;
	}
	static void debug(boolean a[], int n) {
		System.out.println("----------debug---------");
		for (int i = 0; i < n; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println();
		System.out.println("----------debug---------");
	}

	static void debug(long a[][], int n, int m) {
		System.out.println("----------debug---------");
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				System.out.print(a[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();
		System.out.println("----------debug---------");
	}
}

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

/**
 * Created by sbabkin on 9/14/2015.
 */
public class SolverH {

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

    BufferedReader br;
    PrintWriter pw;
    StringTokenizer stok;

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

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

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

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

    private void Run() throws IOException {
//        br=new BufferedReader(new FileReader("input.txt"));
//        pw=new PrintWriter("output.txt");
        br=new BufferedReader(new InputStreamReader(System.in));
        pw=new PrintWriter(new OutputStreamWriter(System.out));

        solve();
        pw.flush();
        pw.close();
    }

    final long del=(long)1e9+7;

    long pow(long num, long pow) {
        if (pow==1) {
            return num;
        }
        long root=pow(num, pow>>1);
        long result=(root*root)%del;
        if ((pow&1)>0){
            result=(result*num)%del;
        }
        return result;
    }

    private void solve() throws IOException {
        int n=nextInt();
        long[] fact = new long[2*n+1];
        long[] invFact=new long[2*n+1];
        fact[0]=1;
        for (int i=1; i<=2*n; i++) {
            fact[i]=(fact[i-1]*i)%del;
        }
        invFact[2*n]=pow(fact[2*n], del-2);
        for (int i=2*n-1; i>=0; i--) {
            invFact[i]=(invFact[i+1]*(i+1))%del;
        }
        long result = 1;
        long curRes = 1;
        for (int i=0; i<n; i++) {
            curRes=(curRes<<1)%del;
            result=(result+curRes)%del;
        }
        for (int i=0; i<n; i++) {
            curRes=(curRes<<1)%del;
            long subst=((fact[n+i]*invFact[i])%del)*invFact[n];
            subst%=del;
            subst=(subst<<1)%del;
            curRes=(curRes-subst)%del;
            result=(result+curRes)%del;
        }
//        long[][] mas=new long[n+1][n+1];
//        long result=-1;
//        for (int i=0; i<=n; i++) {
//            result+=2;
//            mas[i][0]=mas[0][i]=1;
//        }
//        for (int i=1; i<=n; i++) {
//            for (int j=1; j<=n; j++) {
//                mas[i][j]=mas[i-1][j]+mas[i][j-1];
//                result+=mas[i][j];
//            }
//        }

//        for (int j=1; j<=2*n; j++) {
//            int min=Math.max(0, j-n);
//            int max=Math.min(n, j);
//            for (int i=min; i<=max; i++) {
//                long res=mas[i][j-1];
//                if (i>0){
//                    res=(res+mas[i-1][j-1])%del;
//                }
//                mas[i][j]=res;
//                result=(result+mas[i][j])%del;
//            }
//        }
        pw.println(result);
    }

}

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

public class H {
    FastScanner in;
    PrintWriter out;

    public static final long P = 1_000_000_007;
    public void solve() throws IOException {
        int n = in.nextInt();
        long[] d = new long[n + 1];
        long[] s = new long[n + 1];
        long[] x = new long[n + 1];
        d[1] = 5;
        s[1] = 5;
        x[1] = 0;
        for (int i = 2; i <= n; i++) {
            x[i] = (x[i - 1] + 2 * i) % P;
            d[i] = (2 * (x[i] + s[i - 1]) + 1) % P;
            s[i] = (d[i] + s[i - 1]) % P;
        }
        out.println(d[n]);
    }

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

            solve();

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

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

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

        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());
        }
    }

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

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

public class H {
    FastScanner in;
    PrintWriter out;

    public static final long P = 1_000_000_007;
    public void solve() throws IOException {
        int n = in.nextInt();
        long[] d = new long[n + 1];
        d[1] = 5;
        for (int i = 2; i <= n; i++) {
            d[i] = (2 * (2 * i + d[i - 1])+ 1) % P;
        }
        out.println(d[n]);
    }

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

            solve();

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

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

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

        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());
        }
    }

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

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 Artyom Korzun
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskH solver = new TaskH();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskH {
        public static final int MOD = 1_000_000_007;

        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int answer = 0;
            int pow = 1;
            for (int i = 0; i <= n; i++) {
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
            }

            for (int i = 1, c = 1; i <= n; i++) {
                pow = Numbers.moduloSubtract(pow, 2 * c, MOD);
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
                c = recompute(n, i, c);
            }

            out.print(answer);
        }

        private int recompute(int n, int i, int c) {

            int result = Numbers.moduloMultiply(n + i, c, MOD);
            return result % i == 0 ? result / i : result + MOD / i;
        }

    }

    static final class Numbers {
        private Numbers() {
            throw new AssertionError("Not for you!");
        }

        public static int moduloAdd(int i, int j, int mod) {
            long sum = (long) i + j;
            return (int) (sum % mod);
        }

        public static int moduloSubtract(int i, int j, int mod) {
            long subtract = (long) i - j;
            long d = subtract / mod;
            if (d != 0)
                subtract -= d * mod;

            return (int) (subtract < 0 ? mod - subtract : subtract);
        }

        public static int moduloMultiply(int i, int j, int mod) {
            long sum = (long) i * j;
            return (int) (sum % mod);
        }

    }

    static class FastScanner {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

            return tokenizer.nextToken();
        }

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

    }
}

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 Artyom Korzun
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskH solver = new TaskH();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskH {
        public static final int MOD = 1_000_000_007;

        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int answer = 0;
            int pow = 1;
            for (int i = 0; i <= n; i++) {
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
            }

            for (int i = 1, c = 1; i <= n; i++) {
                pow = pow - 2 * c;
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
                c = (n + i) * c / i;
            }

            out.print(answer);
        }

    }

    static final class Numbers {
        private Numbers() {
            throw new AssertionError("Not for you!");
        }

        public static int moduloAdd(int i, int j, int mod) {
            long sum = (long) i + j;
            return (int) (sum % mod);
        }

        public static int moduloMultiply(int i, int j, int mod) {
            long sum = (long) i * j;
            return (int) (sum % mod);
        }

    }

    static class FastScanner {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

            return tokenizer.nextToken();
        }

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

    }
}

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 Artyom Korzun
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskH solver = new TaskH();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskH {
        public static final int MOD = 1_000_000_007;

        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int answer = 0;
            int pow = 1;
            for (int i = 0; i <= n; i++) {
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
            }

            for (int i = 1, c = 1; i <= n; i++) {
                pow = Numbers.moduloSubtract(pow, 2 * c, MOD);
                answer = Numbers.moduloAdd(answer, pow, MOD);
                pow = Numbers.moduloMultiply(pow, 2, MOD);
                c = recompute(n, i, c);
            }

            out.print(answer);
        }

        private int recompute(int n, int i, int c) {
            int result = Numbers.moduloMultiply(n + i, c, MOD);
            return Numbers.moduloMultiply(result, reverse(i), MOD);
        }

        private int reverse(int num) {
            long[] gcd = Numbers.gcdEx(num, MOD);
            return (int) (gcd[1] % MOD + MOD) % MOD;
        }

    }

    static final class Numbers {
        private Numbers() {
            throw new AssertionError("Not for you!");
        }

        public static long[] gcdEx(int a, int b) {
            if (a == 0)
                return new long[]{b, 0, 1};

            long[] d = gcdEx(b % a, a);
            return new long[]{b, d[2] - (b / a) * d[1], d[1]};
        }

        public static int moduloAdd(int i, int j, int mod) {
            long sum = (long) i + j;
            return (int) (sum % mod);
        }

        public static int moduloSubtract(int i, int j, int mod) {
            long subtract = (long) i - j;
            long d = subtract / mod;
            if (d != 0)
                subtract -= d * mod;

            return (int) (subtract < 0 ? mod - subtract : subtract);
        }

        public static int moduloMultiply(int i, int j, int mod) {
            long sum = (long) i * j;
            return (int) (sum % mod);
        }

    }

    static class FastScanner {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public FastScanner(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

            return tokenizer.nextToken();
        }

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

    }
}

import java.util.Scanner;

public class Bots_Kamel_Final_Version {

	final static long BASE = 1_000_000_007;

	public static void main(String [] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		getResult(n);
		sc.close();
	}

	static void getResult(int n) {
		long lev = 1;
		long tot = 1;
		//First part --> Pure doubling
		for(int i = 1; i<=n; i++) {
			lev = (lev*2)%BASE;
			tot = (tot+lev)%BASE;
		}
		long [] modInv = getInverses(n+1);
		long [] combs = getCombs(n+1, 2*n, modInv);
		for(int i = n+1; i<=2*n; i++) {
			lev = 2*(lev - combs[i-n-1]+BASE)%BASE;
			tot = (tot+lev)%BASE;
		}
		System.out.print(tot);
	}

	static long [] getCombs(int start, int end, long [] inverses) {
		long [] ret = new long[end - start+1];
		ret[0] = 1;
		for(int i = 1;  i <ret.length; i++) {
			ret[i] = (ret[i-1]*((start+i-1)*inverses[i])%BASE)%BASE;
		}
		return ret;
	}

	static long [] getInverses(int n) {
		long [] ret = new long[n+1];
		ret[1] = 1;
		for(int i = 2; i < ret.length; i++) {
			ret[i] = (BASE - (BASE/i*ret[(int)BASE%i])%BASE)%BASE;
		}
		return ret;
	}
}

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

public class Bots_Kamel {

	public final static long BASE =  1_000_000_007l;

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

	static void getResult(int n) {
		long level = 1;
		long total = 1;
		BigInteger [] fac = getFacTable(n);
		for(int i = 1; i<=2*n; i++) {
			level = 2*((level-comb(i-1, n, fac) + BASE)%BASE)%BASE;
			total = (total+level)%BASE;
		}
		System.out.println(total);
	}

	static long comb(int i, int n, BigInteger [] fac) {
		if(i<n) {
			return 0;
		}
		else {
			return fac[i-n].longValue();
		}
	}

	static BigInteger [] getFacTable(int n) {
		BigInteger []  ret = new BigInteger[n+1];
		BigInteger base = new BigInteger(String.valueOf(BASE));
		BigInteger N = new BigInteger(String.valueOf(n));
		BigInteger val = new BigInteger(String.valueOf(n));
		ret[0] = BigInteger.ONE;
		for(int i = 1; i<ret.length; i++) {
			val = val.add(BigInteger.ONE);
			ret[i] = ret[i-1].multiply(val).divide(val.subtract(N)).mod(base);
		}
		return ret;
	}
}

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
 */
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);
        h575 solver = new h575();
        solver.solve(1, in, out);
        out.close();
    }

    static class h575 {
        final int mod = (int) (1E9 + 7);

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            long ans = 0;
            long stop = 0;
            for (int i = 0; i <= 2 * n; i++) {
                ans = (ans + pow(i) - stop + mod) % mod;
                stop += bin(i, n);
                stop *= 2;
                stop %= mod;
            }
            out.println(ans);
        }

        long pow(int a) {
            if (a == 0) return 1;
            if (a == 1) return 2;
            long tmp = pow(a / 2);
            if (a % 2 == 0) return (tmp * tmp) % mod;
            return (((tmp * tmp) % mod) * 2) % mod;
        }

        long bin(int n, int k) {
            if (n < k) return 0;
            long res = 1;
            for (int i = 0; i < k; i++) {
                res *= n - i;
            }
            for (int i = 2; i <= k; i++) {
                res /= i;
            }
            return res;
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

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

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

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

    }
}

import java.util.*;
public class ia {
    static final int N = (int) 1e6+3;
    static final int M = (int) 1e9+7;
    static Scanner seer = new Scanner(System.in);
    static int n;
    static long[] fac = new long[2*N+1];
    public static void main(String[] args) {
        calcfac();
        n = seer.nextInt();
        System.out.println(solve(n));
    }
    public static long solve(int n){
        long res = 1;
        for(int i = 0; i < n; i++) res = (2*res)%M;
        long aux = res;
        res = (2*res-1)%M;
        for(int i = 0; i < n; i++){
            long c = C(n+i,n);
            aux = (2*aux - 2*c + M)%M;
            res = (res + aux)%M;
        }
        return res;
    }
    public static long process(int n, int a, int b){
        int res = 0;
        if(a < n) res += process(n,a+1,b);
        if(b < n) res += process(n,a,b+1);
        return res+1;
    }
    public static long C(int n, int k){
        long a = fac[n];
        long b = inv(fac[k]);
        long c = inv(fac[n-k]);
        return (((a*b)%M)*c)%M;
    }
    public static long inv(long n){
        return (mcdex(M,n)[1]%M+M)%M;
    }
    /**
     * returns {p,q} where pa+qb = mcd(a,b);
     * @param a
     * @param b
     * @return
     */
    public static long[] mcdex(long a, long b){ //b es el chico
        if(b == 0){
            long[] res = {1,0};
            return res;
        }
        else{
            long[] mcd = mcdex(b,a%b);
            long p = mcd[0]; long q = mcd[1];
            long[] res = {q,p-(a/b)*q};
            return res;
        }
    }
    public static void calcfac(){
        fac[0] = 1;
        for(int i = 1; i <= 2*N; i++){
            fac[i] = (fac[i-1]*(long)i)%M;
        }
    }

}

import java.io.*;
import java.util.*;
public class H575 {
    static int mod = (int)1e9+7;
public static void main(String[] args) throws IOException {
    input.init(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int n = input.nextInt();
    long res = 0;
    long comb = n;
    for(int i = 0; i<n; i++)
    {
        res = (res + comb*comb)%mod;
        comb = (comb * (n - 1 - i))%mod;
        comb = (comb * invmod(i+2, mod))%mod;
    }
    out.println(res);
    out.close();
}
//GCD - O(log(max(p, q)))
//res[0] is gcd of p and q
//res[1] and res[2] are values used in extended Euclidean algorithm for inverse mod
public static long[] gcd(long p, long q)
{
if(q==0)
    return new long[] {p, 1, 0};
long[] vals = gcd(q, p%q);
return new long[] {vals[0], vals[2], vals[1] - (p/q)*vals[2]};
}
//Inverse Mod - O(log(mod))
//Returns A s.t. x*A = 1(MOD mod)
public static long invmod(long x, long mod)
{
long[] vals = gcd(x, mod);
if(vals[0]>1)
    return -1;
if(vals[1]>0)
    return vals[1];
return mod + vals[1];
}
//Returns array of combinations (Pascals's triangle) up to nCn - O(n^2)
//comb[i][j] represents the value of i choose j
public static int[][] comb(int n)
{
int[][] comb = new int[n+1][n+1];
for(int i = 0; i<= n; i++)
    comb[i][0] = 1;
for(int i = 1; i<= n; i++)
    for(int j = 1; j<= i; j++)
        comb[i][j] = (comb[i-1][j] + comb[i-1][j-1])%mod;
return comb;
}
static int go(int a, int b, int n)
{
    if(a == n && b == n) return 1;
    int res = 1;
    if(a < n) res += go(a+1, b, n);
    if(b < n) res += go(a, b+1, n);
    return res;
}
public static class input {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

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

    static String next() throws IOException {
    while (!tokenizer.hasMoreTokens())
        tokenizer = new StringTokenizer(reader.readLine());
    return tokenizer.nextToken();
    }

    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());
    }
}
}

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

public class test
{
	static long M = 1000000007;
	static long fac[] = new long[2000001];
	static long dp[] = new long[2000001];
	static long x, y;
	static long gcd(long a, long b){
		if(a == 0){x = 0; y = 1; return b;}
		long d = gcd(b%a, a);
		long x1 = x, y1 = y;
		x = y1 - (b / a) * x1;
		y = x1;
		return d;
	}
	static long inv(long a){
		long g = gcd(a, M);
		return (x % M + M) % M;
	}
	static long C(long n, long k){
		if(k > n){return 0;}
		return fac[(int)n] * inv(fac[(int)k] * fac[(int)(n - k)] % M) % M;
	}
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		long n, ans = 1;
		n = in.nextLong();
		fac[0] = 1;
		dp[0] = 1;
		for(int i = 1; i <= 2*n; i++){fac[i] = fac[i - 1] * i % M; dp[i] = (2 * dp[i - 1] - 2 * C(i - 1, n) + M)%M; ans += dp[i];}
		out.println(ans);
		out.flush();
	}
}