#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

#define clr(x) memset((x), 0, sizeof(x))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define sz size()
#define For(i, st, en) for(int i=(st); i<=(int)(en); i++)
#define Ford(i, st, en) for(int i=(st); i>=(int)(en); i--)
#define forn(i, n) for(int i=0; i<(int)(n); i++)
#define ford(i, n) for(int i=(n)-1; i>=0; i--)
#define fori(it, x) for (__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)

FILE *g_f_;
int g_s_;
#define freopen(a, b, c) (g_f_ = freopen(a, b, c))
#define scanf(...) (g_s_ = scanf(__VA_ARGS__))
#define sscanf(...) (g_s_ = sscanf(__VA_ARGS__))

template <class _T> inline _T sqr(const _T& x) { return x * x; }
template <class _T> inline string tostr(const _T& a) { ostringstream os(""); os << a; return os.str(); }

typedef long double ld;

// Constants
const ld PI = 3.1415926535897932384626433832795;
const ld EPS = 1e-11;

// Types
typedef signed   long long i64;
typedef unsigned long long u64;
typedef set < int > SI;
typedef vector < int > VI;
typedef map < string, int > MSI;
typedef pair < int, int > PII;

const int nm00[] = {0,1,2,3,5,6,7,8,9,10,11,12,13,14,15,16};
const int nm01[] = {4,17,18,19,20,21,22,23,24};

const int nm10[] = {0,9,13,7,14,2,11,5,6};
const int nm11[] = {4,17,18,21,19,24};

const int nm20[] = {0,1,5,7,8,9,10,13,15};
const int nm21[] = {4,17,19,20,21,22};

const int nm30[] = {0,1,5,9,10,13,15,7};
const int nm31[] = {4,21,17,22,19};


const int sq00[] = {0,1,2,3,5,6,7,8,9,10,11,12,13,14,15,16};
const int sq01[] = {4,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32};

const int sq10[] = {0,2,5,6,7,9,11,13,14};
const int sq11[] = {4,17,20,21,22,23,25,26,29,30};

const int sq20[] = {0,1,5,7,8,9,10,13,15};
const int sq21[] = {4,17,19,21,23,24,25,26,27,28};

const int sq30[] = {0,1,5,8,9,10,13,15};
const int sq31[] = {4,17,19,21,24,25,26,27,28};

const int sq40[] = {0,9,10,5};
const int sq41[] = {4,17,25,26,21};

const int sq50[] = {0,1,3,9,5,10,8,15,16};
const int sq51[] = {4,17,18,19,21,24,25,27,28,31};

const int sq60[] = {0,9,10,5};
const int sq61[] = {4,17,25,26,21};

const int sq70[] = {0,1,3,9,5,10,8,15,16};
const int sq71[] = {4,17,18,19,21,24,25,27,28,31};

const int MOD = 1000000007;

const int MAXN = 1001;

int d[MAXN + 2][MAXN + 2];
int ds[MAXN + 2][MAXN + 2];
int p2[MAXN * MAXN + 1];
int r2[4];

inline int mypow(int a, i64 k)
{
	if (!k) return 1;
	if (k == 1) return a;
	int ans = mypow(a, k/2);
	ans = ans * (i64)ans % MOD;
	if (k & 1) ans = ans * (i64)a % MOD;
	return ans;
}

inline int solve_one(int n)
{
	if (n == 1) return 1;
	n -= 2;
	int ans = p2[n] + p2[(n + 1) / 2];
	if (ans >= MOD) ans -= MOD;
	return ans * (i64)r2[1] % MOD;
//	return (mypow(2, n) + mypow(2, (n + 1) / 2)) % MOD * (i64)mypow(2, MOD-2) % MOD;
}

inline void add(int &a, int b)
{
	a += b;
	a -= (a >= MOD) * MOD;
}

inline void sub(int &a, int b)
{
	a -= b;
	a += (a < 0) * MOD;
}

inline int pow2(i64 k)
{
	if (k < MAXN * MAXN) return p2[k];
	else return mypow(2, k);
}

i64 s_eq(int n)
{
	if (n == 1) return 1;
	i64 c[33] = {};

	c[0] = c[1] = c[2] = c[3] = 1;
	c[4] = (n % 2 == 1);
	c[5] = c[6] = c[7] = c[8] = (n % 2 == 1);
	c[9] = c[10] = c[11] = c[12] = (n - 2) / 2;
	c[13] = c[14] = c[15] = c[16] = (n - 2) / 2;
	c[17] = c[18] = c[19] = c[20] = (n - 2) / 2;
	c[21] = c[22] = c[23] = c[24] = (n - 2) / 2 * (n % 2 == 1);
	c[25] = c[26] = c[27] = c[28] = c[29] = c[30] = c[31] = c[32] = (c[9] - 1) * c[9] / 2;

	int ans = 0, cnt, s0, s1;

#define calc_sum2(x, y) do { int k = sizeof(sq##x##y) / sizeof(sq##x##y[0]); s##y = 0; forn(i, k) { s##y += c[sq##x##y[i]]; } } while (0)
#define calc_sum(x) do { calc_sum2(x, 0); calc_sum2(x, 1); } while (0)

	int n2 = (n+1)/2;

	calc_sum(0);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
	add(cnt, pow2(s0-n-n));
	add(cnt, pow2(s0-n-n));
	add(cnt, pow2(s0-n-n+1));
	add(cnt, pow2(s0-n-n+1));
	add(cnt, pow2(s0-n-n+1));
	add(cnt, pow2(s0-n-n+1));
	sub(cnt, pow2(s0-n-n-n+2));
	sub(cnt, pow2(s0-n-n-n+2));
	sub(cnt, pow2(s0-n-n-n+2));
	sub(cnt, pow2(s0-n-n-n+2));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(1);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n2));
	sub(cnt, pow2(s0-n2));
//	add(cnt, pow2(s0-n));
	add(cnt, pow2(s0-n2-n2));
	add(cnt, pow2(s0-n-n2+1));
	add(cnt, pow2(s0-n-n2+1));
//	add(cnt, pow2(s0-n-n2+1));
//	add(cnt, pow2(s0-n-n2+1));
//	sub(cnt, pow2(s0-n-n2+1));
//	sub(cnt, pow2(s0-n-n2+1));
	sub(cnt, pow2(s0-n2-n2-n+2));
	sub(cnt, pow2(s0-n2-n2-n+2));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(2);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n2));
	sub(cnt, pow2(s0-n2));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
	add(cnt, pow2(s0-n2-n2));
//	add(cnt, pow2(s0-n));
	add(cnt, pow2(n2-1));
	add(cnt, pow2(n2-1));
//	add(cnt, pow2(n2-1));
//	add(cnt, pow2(n2-1));
//	sub(cnt, pow2(n2-1));
//	sub(cnt, pow2(n2-1));
	sub(cnt, pow2(s0-n2-n2-n+2));
	sub(cnt, pow2(s0-n2-n2-n+2));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(3);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(4);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(5);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(6);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(7);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

#undef calc_sum
#undef calc_sum2

	ans = ans * (i64)r2[3] % MOD;

	return ans;
}

i64 s_neq(int n, int m)
{
	if (n > m) swap(n, m);
	if (n == 1) return solve_one(m);
	i64 c[25] = {};

	c[0] = c[1] = c[2] = c[3] = 1;
	c[4] = (n % 2 == 1) && (m % 2 == 1);
	c[5] = c[6] = (m % 2 == 1);
	c[7] = c[8] = (n % 2 == 1);
	c[9] = c[10] = c[11] = c[12] = (m - 2) / 2;
	c[13] = c[14] = c[15] = c[16] = (n - 2) / 2;
	c[17] = c[18] = c[13] * (m % 2 == 1);
	c[19] = c[20] = c[9] * (n % 2 == 1);
	c[21] = c[22] = c[23] = c[24] = c[9] * c[13];

	int ans = 0, cnt, s0, s1;

#define calc_sum2(x, y) do { int k = sizeof(nm##x##y) / sizeof(nm##x##y[0]); s##y = 0; forn(i, k) { s##y += c[nm##x##y[i]]; } } while (0)
#define calc_sum(x) do { calc_sum2(x, 0); calc_sum2(x, 1); } while (0)

	int n2 = (n+1)/2;
	int m2 = (m+1)/2;

	calc_sum(0);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-m));
	sub(cnt, pow2(s0-m));
	add(cnt, pow2(s0-n-n));
	add(cnt, pow2(s0-m-m));
	add(cnt, pow2(s0-n-m+1));
	add(cnt, pow2(s0-n-m+1));
	add(cnt, pow2(s0-n-m+1));
	add(cnt, pow2(s0-n-m+1));
	sub(cnt, pow2(s0-n-n-m+2));
	sub(cnt, pow2(s0-n-n-m+2));
	sub(cnt, pow2(s0-m-m-n+2));
	sub(cnt, pow2(s0-m-m-n+2));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(1);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-m2));
	sub(cnt, pow2(s0-m2));
//	add(cnt, pow2(s0-n));
	add(cnt, pow2(s0-m2-m2));
	add(cnt, pow2(s0-n-m2+1));
	add(cnt, pow2(s0-n-m2+1));
//	add(cnt, pow2(s0-n-m2+1));
//	add(cnt, pow2(s0-n-m2+1));
//	sub(cnt, pow2(s0-n-m2+1));
//	sub(cnt, pow2(s0-n-m2+1));
	sub(cnt, pow2(s0-m2-m2-n+2));
	sub(cnt, pow2(s0-m2-m2-n+2));
//	cerr << s0-m2-m2-n+2 << " == 0" << endl;
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(2);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n2));
	sub(cnt, pow2(s0-n2));
	sub(cnt, pow2(s0-m));
//	sub(cnt, pow2(s0-m));
	add(cnt, pow2(s0-n2-n2));
//	add(cnt, pow2(s0-m));
	add(cnt, pow2(n2-1));
	add(cnt, pow2(n2-1));
//	add(cnt, pow2(n2-1));
//	add(cnt, pow2(n2-1));
//	sub(cnt, pow2(n2-1));
//	sub(cnt, pow2(n2-1));
	sub(cnt, pow2(s0-n2-n2-m+2));
	sub(cnt, pow2(s0-n2-n2-m+2));
//	cerr << s0-n2-n2-m+2 << " == 0" << endl;
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

	calc_sum(3);
	cnt = 0;
	add(cnt, pow2(s0));
	sub(cnt, pow2(s0-n));
//	sub(cnt, pow2(s0-n));
	sub(cnt, pow2(s0-m));
//	sub(cnt, pow2(s0-m));
//	add(cnt, pow2(s0-n));
//	add(cnt, pow2(s0-m));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	add(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
//	sub(cnt, pow2(0));
	add(cnt, pow2(0));
	cnt = cnt * (i64)pow2(s1) % MOD;
	ans = (ans + cnt) % MOD;

#undef calc_sum
#undef calc_sum2

	ans = ans * (i64)r2[2] % MOD;
//	ans = ans * (i64)mypow(4, MOD-2) % MOD;

	return ans;
}

void precalc()
{
	p2[0] = 1;
	r2[0] = 1;
	r2[1] = pow2(MOD - 2);
	r2[2] = r2[1] * (i64)r2[1] % MOD;
	r2[3] = r2[2] * (i64)r2[1] % MOD;
	int ma = MAXN;
	For(i, 1, MAXN * MAXN)
	{
		p2[i] = p2[i-1] * 2;
		if (p2[i] >= MOD) p2[i] -= MOD;
	}
	clr(d);
	clr(ds);
	For(i, 1, ma)
	{
		For(j, 1, i)
		{
			if (i == j)
			{
				d[i][j] = s_eq(i);
			}
			else
			{
				d[i][j] = d[j][i] = s_neq(i, j);
			}
		}
	}
	For(i, 1, ma)
	{
		For(j, 1, i)
		{
			if (i != j)
			{
				ds[i][j] = ds[i-1][j];
				add(ds[i][j], ds[i][j-1]);
				sub(ds[i][j], ds[i-1][j-1]);
				add(ds[i][j], d[i][j]);
			}
			else
			{
				ds[i][j] = ds[i-1][j];
				add(ds[i][j], d[i][j]);
			}
			ds[j][i] = ds[i][j];
		}
	}
}

int main()
{
#ifdef ROOM_311
	time_t et_0 = clock();
#endif
	cout << setiosflags(ios::fixed) << setprecision(10);

	precalc();

	for(;;)
	{
		int n, m;
		scanf("%d%d", &n, &m);
		if (!n) break;
		int z = ds[n][m];
		printf("%d\n", z);
	}

#ifdef ROOM_311
	time_t et_1 = clock();
	fprintf(stderr, "Execution time = %0.0lf ms\n", (et_1 - et_0) * 1000.0 / CLOCKS_PER_SEC);
#endif
	return 0;
}