Ayoub had an array a of integers of size n and this array had two interesting properties: 

  * All the integers in the array were between l and r (inclusive). 
  * The sum of all the elements was divisible by 3. 



Unfortunately, Ayoub has lost his array, but he remembers the size of the array n and the numbers l and r, so he asked you to find the number of ways to restore the array. 

Since the answer could be very large, print it modulo 10^9 + 7 (i.e. the remainder when dividing by 10^9 + 7). In case there are no satisfying arrays (Ayoub has a wrong memory), print 0.

Input

The first and only line contains three integers n, l and r (1 ≤ n ≤ 2 ⋅ 10^5 , 1 ≤ l ≤ r ≤ 10^9) — the size of the lost array and the range of numbers in the array.

Output

Print the remainder when dividing by 10^9 + 7 the number of ways to restore the array.

Examples

Input


2 1 3


Output


3


Input


3 2 2


Output


1


Input


9 9 99


Output


711426616

Note

In the first example, the possible arrays are : [1,2], [2,1], [3, 3].

In the second example, the only possible array is [2, 2, 2].
//package sol2;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Solution {

  static long MOD = (long)1e9 + 7;
  static long T, x;

  static int ret=0;

  public static void main(String[] args) throws IOException {
    FastInput fi = new FastInput(System.in);
    PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    int n = fi.nextInt(), l = fi.nextInt(), r= fi.nextInt();

    long[][] dp = new long[200005][3];
    dp[0][0]=1;
//    dp[0][1]=1;
//    dp[0][2]=1;
    int rem0 = (r/3) - ((l-1)/3);
    int rem1 = count(r,1)-count(l-1, 1);
    int rem2 = count(r,2) - count(l-1, 2);

    for(int i = 1; i<=n; i++) {
      dp[i][0] = ( (dp[i-1][0] * rem0)%MOD + (dp[i-1][1] * rem2)%MOD + (dp[i-1][2] * rem1)%MOD ) %MOD;
      dp[i][1] = ( (dp[i-1][0] * rem1)%MOD + (dp[i-1][1] * rem0)%MOD + (dp[i-1][2] * rem2)%MOD ) %MOD;
      dp[i][2] = ( (dp[i-1][0] * rem2)%MOD + (dp[i-1][1] * rem1)%MOD + (dp[i-1][2] * rem0)%MOD ) %MOD;
    }

    System.out.println(dp[n][0]%MOD);
  }

  static int count(int a, int m) {
    a+=3;
    return (int)((a-m+3)/3);
  }

  static class Pair<K extends Comparable, V extends Comparable> implements Comparable {
    K key;
    V value;

    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (!(o instanceof Pair)) {
        return false;
      }
      Pair<?, ?> pair = (Pair<?, ?>) o;
      return Objects.equals(key, pair.key) &&
          Objects.equals(value, pair.value);
    }

    @Override
    public int hashCode() {
      return Objects.hash(key, value);
    }

    public Pair(K key, V value) {
      this.key = key;
      this.value = value;
    }

    @Override
    public int compareTo(Object o) {
      Pair<K, V> p = (Pair)o;
      if(p.key.compareTo(this.key) > 0)
        return 1;
      else if(p.key.compareTo(this.key) < 0)
        return -1;
      else {
        if(p.value.compareTo(this.value) > 0)
          return 1;
        else if(p.value.compareTo(this.value) < 0)
          return -1;
        else return 0;
      }
    }
  }


private static class FastInput {

    BufferedReader  reader;
    StringTokenizer st;

    public FastInput(InputStream inputStream) {
      reader = new BufferedReader(new InputStreamReader(inputStream), 32768);
    }

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

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

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