#include <fstream>
#include <algorithm>

using namespace std;

const char iname[] = "c:\\in.txt";
const char oname[] = "c:\\out.txt";

#define FOR(i, a, b)  for (int i = (a); i <= (b); ++ i)
#define FORR(i, b, a) for (int i = (b); i >= (a); -- i)
#define lastbit(x) ((x) ^ ((x) & ((x) - 1)))

#define MAXN	  501
#define MAXVALUE  501

#define modulo 666013

int A[MAXN] = {0, 1, 1, 1, 1, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20, 20, 25, 25, 25, 25, 25, 30, 30, 30, 30, 30, 35, 35, 35, 35, 35, 40, 40, 40, 40, 40, 45, 45, 45, 45, 45, 50, 50, 50, 50, 50, 55, 55, 55, 55, 55, 60, 60, 60, 60, 60, 65, 65, 65, 65, 65, 70, 70, 70, 70, 70, 75, 75, 75, 75, 75, 80, 80, 80, 80, 80, 85, 85, 85, 85, 85, 90, 90, 90, 90, 90, 95, 95, 95, 95, 95, 100, 100, 100, 100, 100, 105, 105, 105, 105, 105, 110, 110, 110, 110, 110, 115, 115, 115, 115, 115, 120, 120, 120, 120, 120, 125, 125, 125, 125, 125, 130, 130, 130, 130, 130, 135, 135, 135, 135, 135, 140, 140, 140, 140, 140, 145, 145, 145, 145, 145, 150, 150, 150, 150, 150, 155, 155, 155, 155, 155, 160, 160, 160, 160, 160, 165, 165, 165, 165, 165, 170, 170, 170, 170, 170, 175, 175, 175, 175, 175, 180, 180, 180, 180, 180, 185, 185, 185, 185, 185, 190, 190, 190, 190, 190, 195, 195, 195, 195, 195, 200, 200, 200, 200, 200, 205, 205, 205, 205, 205, 210, 210, 210, 210, 210, 215, 215, 215, 215, 215, 220, 220, 220, 220, 220, 225, 225, 225, 225, 225, 230, 230, 230, 230, 230, 235, 235, 235, 235, 235, 240, 240, 240, 240, 240, 245, 245, 245, 245, 245, 250, 250, 250, 250, 250, 255, 255, 255, 255, 255, 260, 260, 260, 260, 260, 265, 265, 265, 265, 265, 270, 270, 270, 270, 270, 275, 275, 275, 275, 275, 280, 280, 280, 280, 280, 285, 285, 285, 285, 285, 290, 290, 290, 290, 290, 295, 295, 295, 295, 295, 300, 300, 300, 300, 300, 305, 305, 305, 305, 305, 310, 310, 310, 310, 310, 315, 315, 315, 315, 315, 320, 320, 320, 320, 320, 325, 325, 325, 325, 325, 330, 330, 330, 330, 330, 335, 335, 335, 335, 335, 340, 340, 340, 340, 340, 345, 345, 345, 345, 345, 350, 350, 350, 350, 350, 355, 355, 355, 355, 355, 360, 360, 360, 360, 360, 365, 365, 365, 365, 365, 370, 370, 370, 370, 370, 375, 375, 375, 375, 375, 380, 380, 380, 380, 380, 385, 385, 385, 385, 385, 390, 390, 390, 390, 390, 395, 395, 395, 395, 395, 400, 400, 400, 400, 400, 405, 405, 405, 405, 405, 410, 410, 410, 410, 410, 415, 415, 415, 415, 415, 420, 420, 420, 420, 420, 425, 425, 425, 425, 425, 430, 430, 430, 430, 430, 435, 435, 435, 435, 435, 440, 440, 440, 440, 440, 445, 445, 445, 445, 445, 450, 450, 450, 450, 450, 455, 455, 455, 455, 455, 460, 460, 460, 460, 460, 465, 465, 465, 465, 465, 470, 470, 470, 470, 470, 475, 475, 475, 475, 475, 480, 480, 480, 480, 480, 485, 485, 485, 485, 485, 490, 490, 490, 490, 490, 495, 495, 495, 495, 495, 500};

int B[MAXN] = {0, 1, 1, 1, 1, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20, 20, 20, 20, 20, 25, 25, 25, 25, 25, 30, 30, 30, 30, 30, 35, 35, 35, 35, 35, 40, 40, 40, 40, 40, 45, 45, 45, 45, 45, 50, 50, 50, 50, 50, 55, 55, 55, 55, 55, 60, 60, 60, 60, 60, 65, 65, 65, 65, 65, 70, 70, 70, 70, 70, 75, 75, 75, 75, 75, 80, 80, 80, 80, 80, 85, 85, 85, 85, 85, 90, 90, 90, 90, 90, 95, 95, 95, 95, 95, 100, 100, 100, 100, 100, 105, 105, 105, 105, 105, 110, 110, 110, 110, 110, 115, 115, 115, 115, 115, 120, 120, 120, 120, 120, 125, 125, 125, 125, 125, 130, 130, 130, 130, 130, 135, 135, 135, 135, 135, 140, 140, 140, 140, 140, 145, 145, 145, 145, 145, 150, 150, 150, 150, 150, 155, 155, 155, 155, 155, 160, 160, 160, 160, 160, 165, 165, 165, 165, 165, 170, 170, 170, 170, 170, 175, 175, 175, 175, 175, 180, 180, 180, 180, 180, 185, 185, 185, 185, 185, 190, 190, 190, 190, 190, 195, 195, 195, 195, 195, 200, 200, 200, 200, 200, 205, 205, 205, 205, 205, 210, 210, 210, 210, 210, 215, 215, 215, 215, 215, 220, 220, 220, 220, 220, 225, 225, 225, 225, 225, 230, 230, 230, 230, 230, 235, 235, 235, 235, 235, 240, 240, 240, 240, 240, 245, 245, 245, 245, 245, 250, 250, 250, 250, 250, 255, 255, 255, 255, 255, 260, 260, 260, 260, 260, 265, 265, 265, 265, 265, 270, 270, 270, 270, 270, 275, 275, 275, 275, 275, 280, 280, 280, 280, 280, 285, 285, 285, 285, 285, 290, 290, 290, 290, 290, 295, 295, 295, 295, 295, 300, 300, 300, 300, 300, 305, 305, 305, 305, 305, 310, 310, 310, 310, 310, 315, 315, 315, 315, 315, 320, 320, 320, 320, 320, 325, 325, 325, 325, 325, 330, 330, 330, 330, 330, 335, 335, 335, 335, 335, 340, 340, 340, 340, 340, 345, 345, 345, 345, 345, 350, 350, 350, 350, 350, 355, 355, 355, 355, 355, 360, 360, 360, 360, 360, 365, 365, 365, 365, 365, 370, 370, 370, 370, 370, 375, 375, 375, 375, 375, 380, 380, 380, 380, 380, 385, 385, 385, 385, 385, 390, 390, 390, 390, 390, 395, 395, 395, 395, 395, 400, 400, 400, 400, 400, 405, 405, 405, 405, 405, 410, 410, 410, 410, 410, 415, 415, 415, 415, 415, 420, 420, 420, 420, 420, 425, 425, 425, 425, 425, 430, 430, 430, 430, 430, 435, 435, 435, 435, 435, 440, 440, 440, 440, 440, 445, 445, 445, 445, 445, 450, 450, 450, 450, 450, 455, 455, 455, 455, 455, 460, 460, 460, 460, 460, 465, 465, 465, 465, 465, 470, 470, 470, 470, 470, 475, 475, 475, 475, 475, 480, 480, 480, 480, 480, 485, 485, 485, 485, 485, 490, 490, 490, 490, 490, 495, 495, 495, 495, 495, 500};

int C[MAXN] = {0, 1, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100, 105, 110, 115, 120, 125, 130, 135, 140, 145, 150, 155, 160, 165, 170, 175, 180, 185, 190, 195, 200, 205, 210, 215, 220, 225, 230, 235, 240, 245, 250, 255, 260, 265, 270, 275, 280, 285, 290, 295, 300, 305, 310, 315, 320, 325, 330, 335, 340, 345, 350, 355, 360, 365, 370, 375, 380, 385, 390, 395, 400, 405, 410, 415, 420, 425, 430, 435, 440, 445, 450, 455, 460, 465, 470, 475, 480, 485, 490, 495, 500};

int Sum[2][MAXN][MAXN], SumV[2][MAXVALUE][MAXN];


inline void update(int &var, int val) {
	if (val < 0)
		val += modulo;
	if ((var += val) >= modulo)
		var -= modulo;
}

int query(int M[][MAXN], int i, int j) 
{
	int ret = 0;
	for (; i > 0; i -= lastbit(i))
		if ((ret += M[i][j]) >= modulo)
			ret -= modulo;
	return ret;
}

void update(int M[][MAXN], int i, int j, int val) 
{
	for (; i < MAXVALUE; i += lastbit(i))
		if ((M[i][j] += val) >= modulo)
			M[i][j] -= modulo;
}

int main(void)
{
	int n = 500, m = 500, p = 100;
	int Cnt[MAXN];

	int r = 0, ret = 0;
	
	FOR (i, 1, n)
	{
		FOR (j, 1, m)
			Sum[r][i][j] = query(SumV[r], A[i], j);

		memset(Cnt, 0, sizeof(Cnt));
		FOR (j, 1, m) if (A[i] == B[j])
		{
			Cnt[j] = 1;
			update(Cnt[j], Sum[r][i][1] - Sum[r][i][j]);
		}
		
		int tsum = 0;
		FORR (j, m, 1) {
			if ((tsum += Cnt[j]) >= modulo)
				tsum -= modulo;
			update(SumV[r], A[i], j, tsum);
		}
	}

	FOR (k, 1, p) 
	{
		r ^= 1;
		memset(SumV[r], 0, sizeof(SumV[r]));
		
		FOR (i, 1, n)
		{
			FOR (j, 1, m)
				Sum[r][i][j] = query(SumV[r], A[i], j);

			memset(Cnt, 0, sizeof(Cnt));
			FOR (j, 1, m) if (A[i] == B[j]) 
			{
				Cnt[j] = 0;

				if (A[i] == C[k])
				{
					if (k == 1)
						Cnt[j] = 1;
					update(Cnt[j], Sum[r ^ 1][i][1] - Sum[r ^ 1][i][j]);
				} 
				else
					update(Cnt[j], Sum[r][i][1] - Sum[r][i][j]);
			}

			int tsum = 0;
			FORR (j, m, 1) {
				if ((tsum += Cnt[j]) >= modulo)
					tsum -= modulo;
				update(SumV[r], A[i], j, tsum);
			}

			if (k == p)
				FOR (j, 1, m) if (A[i] == B[j])
					if ((ret += Cnt[j]) >= modulo)
						ret -= modulo;
		}
	}

	return 0;
}