Recently Ivan the Fool decided to become smarter and study the probability theory. He thinks that he understands the subject fairly well, and so he began to behave like he already got PhD in that area.

To prove his skills, Ivan decided to demonstrate his friends a concept of random picture. A picture is a field of n rows and m columns, where each cell is either black or white. Ivan calls the picture random if for every cell it has at most one adjacent cell of the same color. Two cells are considered adjacent if they share a side.

Ivan's brothers spent some time trying to explain that it's not how the randomness usually works. Trying to convince Ivan, they want to count the number of different random (according to Ivan) pictures. Two pictures are considered different if at least one cell on those two picture is colored differently. Since the number of such pictures may be quite large, print it modulo 10^9 + 7.

Input

The only line contains two integers n and m (1 ≤ n, m ≤ 100 000), the number of rows and the number of columns of the field.

Output

Print one integer, the number of random pictures modulo 10^9 + 7.

Example

Input


2 3


Output


8

Note

The picture below shows all possible random pictures of size 2 by 3. 

<image>
import java.util.*;
import java.io.*;


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);
        Solver solver = new Solver();
        int t = 1;
        for(int i=0;i<t;i++) {
            solver.solve(i, in, out);    
        }
        out.close();
    }
        
    static int rec(int i,int j,int n,int m,int[][] ans) {
        if(i == n - 1 && j == m - 1) {
            ans[i][j] = 1;
            int p = isGood(n,m,ans);
            ans[i][j] = 0;
            int q = isGood(n,m,ans);
            return p + q;
        }
        if(j == m) {
            j = 0;
            i++;
        }
        ans[i][j] = 1;
        int p = rec(i, j + 1, n, m, ans);
        ans[i][j] = 0;
        int q = rec(i, j + 1, n, m, ans);
        return p + q;
    }

    private static int isGood(int n,int m,int[][] ans) {
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
              int left = j > 0 ? ans[i][j - 1] : -1;
              int right = j < m - 1 ? ans[i][j + 1] : -1;
              int up = i > 0 ? ans[i - 1][j] : -1;
              int down = i < n - 1 ? ans[i + 1][j] : -1;

              int cnt = 0;

              if(left == ans[i][j])cnt++;
              if(right == ans[i][j])cnt++;
              if(up == ans[i][j])cnt++;
              if(down == ans[i][j])cnt++;

              if(cnt > 1) {
                return 0;
              }  
            }
        }
        // for(int i=0;i<n;i++,System.out.println()) {
        //     for(int j=0;j<m;j++){
        //         System.out.print(ans[i][j]+ " ");
        //     }
        // }
        // System.out.println();
        return 1;
    }

   static void brute(int n,int m) {
        int[][] mat = new int[n][m];
        System.out.println("Brute: " + rec(0,0,n,m,mat));
    }

    private static long MOD = 1000000007;

    static class Solver {
        public void solve(int testNumber, InputReader sc, PrintWriter out) {
            int n = sc.nextInt();
            int m = sc.nextInt();

            if(m < n) {
                int temp = n;
                n = m;
                m = temp; 
            }

            long ansOnStripe = getAnsOnStripe(m);
    
            out.println((getAnsOnStripe(m) + getAnsOnStripe(n) - 2 + MOD) % MOD);
        }

        private long getAnsOnStripe(int m) {
            long a = 2, b = 0;

            for(int i = 2; i <= m; i++) {
                long na = (b + a) % MOD;    //na b - w b
                long nb = a;    //nb b - b
                a = na % MOD;
                b = nb % MOD;
            }

            return (a + b) % MOD;
        }
    }
 
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
        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 String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        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 - '0';
                c = read();
            }
            while (!isSpaceChar(c)); 
            
            return res * sgn;
        }
        
        public long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            while (!isSpaceChar(c));
                return res * sgn;
        }
        
        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
        
        public String readString() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } 
            while (!isSpaceChar(c));
            
            return res.toString();
        }
     
        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
     
        public String next() {
            return readString();
        }
        
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
}