import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;

public class Hack52B{

	void solve()
	{
		int n = ni(), k = ni(), x = ni();
		long mod = 1000000007;
		long ans = 0;
		k--;
		for(int i=2;i<n;i++)
		{
			ans = ans * k % mod;
			if(i % 2 == 0)
				ans += k;
			else
				ans -= k;
			ans = (ans + mod) % mod;
		}
		
		if(x != 1)
			if(n % 2 == 1)
				ans += (mod - 1);
			else
				ans++;
		
		out.println(ans % mod);
		
//		int[] a = new int[n];
//		Arrays.fill(a, 1);
//		a[n-1] = x;
//		int cn = 0;
//		do {
//			System.out.println(Arrays.toString(a));
//			if(valid(a))
//				cn++;
//		}while(next(a, k));
//		out.println(cn);
	}
	
	boolean next(int[] a, int k)
	{
		int ptr = a.length-2;
		while(ptr > 0 && a[ptr] == k)
			a[ptr--] = 1;
		if(ptr == 0)
			return false;
		a[ptr]++;
		return true;
	}
	
	boolean valid(int[] a)
	{
		for(int i=1;i<a.length;i++)
			if(a[i] == a[i-1])
				return false;
		return true;
	}
	
	public static void main(String[] args){new Hack52B().run();}
	
	private byte[] bufferArray = new byte[1024];
	private int bufLength = 0;
	private int bufCurrent = 0;
	InputStream inputStream;
	PrintWriter out;
	
	public void run()
	{
		inputStream = System.in;
		out = new PrintWriter(System.out);
//		while(true)
		{
			solve();
			out.flush();
		}
	}
	
	int nextByte()
	{
		if(bufLength == -1)
			throw new InputMismatchException();
		if(bufCurrent >= bufLength)
		{
			bufCurrent = 0;
			try
			{bufLength = inputStream.read(bufferArray);}
			catch(IOException e)
			{ throw new InputMismatchException();}
			if(bufLength <= 0)
				return -1;
		}
		return bufferArray[bufCurrent++];
	}
	
	boolean isSpaceChar(int x)
	{return (x < 33 || x > 126);}
	
	boolean isDigit(int x)
	{return (x >= '0' && x <= '9');}
	
	int nextNonSpace()
	{
		int x;
		while((x=nextByte()) != -1 && isSpaceChar(x));
		return x;
	}
	
	int ni()
	{
		long ans = nl();
		if (ans >= Integer.MIN_VALUE && ans <= Integer.MAX_VALUE)
			return (int)ans;
		throw new InputMismatchException();
	}
	
	long nl()
	{
		long ans = 0;
		boolean neg = false;
		int x = nextNonSpace();
		if(x == '-') 
		{
			neg = true;
			x = nextByte();
		}
		while(!isSpaceChar(x))
		{
			if(isDigit(x))
			{
				ans = ans * 10 + x -'0';
				x = nextByte();
			}
			else
				throw new InputMismatchException();
		}
		return neg ? -ans : ans;
	}
	
	String ns()
	{
		StringBuilder sb = new StringBuilder();
		int x = nextNonSpace();
		while(!isSpaceChar(x))
		{
			sb.append((char)x);
			x = nextByte();
		}
		return sb.toString();
	}
	
	char nc()
	{ return (char)nextNonSpace();}
	
	double nd()
	{ return (double)Double.parseDouble(ns()); }
	
	char[] ca()
	{ return ns().toCharArray();}
	
	char[] ca(int n)
	{
		char[] ans = new char[n];
		int p = 0;
		int x = nextNonSpace();
		while(p<n)
		{
			ans[p++] = (char)x;
			x = nextByte();
		}
		return ans;
	}
	
	int[] ia(int n)
	{
		int[] ans = new int[n];
		for(int i=0;i<n;i++)
			ans[i] = ni();
		return ans;
	}
	
}