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.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.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---------");
	}
}

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

}

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

/*
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.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.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.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.*;
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.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.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.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);
    }
}

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