#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <functional>
#include <map>
#include <iomanip>
#include <math.h> 
#include <stack>
#include <queue>
#include <bitset>
#include <cstdlib>
#include <tuple>
#include <cctype>
#include <ctype.h>
#include <set>
#include <sstream>

using namespace std;
//int db, dc;
int a1000, a100, a, b1000, b100, b, c1000, c100, c;

int funcb(int db, int bb1000, int bb100, int bb, int flag, int flag2) {
	int cnt = 0;
	int n1000 = db / 1000;
	int n100 = (db - (n1000 * 1000)) / 100;
	int n = db - (n1000 * 1000 + n100 * 100);

	while (true)
	{
		if (bb1000 >= n1000) {
			bb1000 -= n1000;
		}
		else if( (n1000 - bb1000) * 1000 <= bb100 * 100){
			bb100 -= ((n1000 - bb1000) * 1000) / 100;
			bb1000 = 0;
		}
		else if ( n1000 * 1000 <= bb1000 * 1000 + bb100 * 100 + bb) {
			bb -= (n1000 * 1000) - (bb1000 * 1000 + bb100 * 100);
			bb1000 = 0;
			bb100 = 0;
		}
		else {
			break;
		}


		if (bb100 >= n100) {
			bb100 -= n100;
		}
		else if ((n100 - bb100) * 100 <= bb) {
			bb -= ((n100 - bb100) * 100);
			bb100 = 0;
		}
		else {
			break;
		}

		if (bb >= n) {
			bb -= n;
		}
		else {
			break;
		}

		if (flag2 == true) {
			bb1000 += b1000;
			bb100 += b100;
			bb += b;
		}
		else {
			bb1000 += c1000;
			bb100 += c100;
			bb += c;
		}

		if (flag == 1)return bb1000;
		if (flag == 2)return bb100;
		if (flag == 3)return bb;

		cnt++;
	}



	return cnt;
}


int main(){
	int i, j;
	//int a1000, a100, a, b1000, b100, b, c1000, c100, c;
	int db, dc;
	//int dpb[100000][3];
	//int dpc[100000][3];
	int dpb[100000][6];
	int dpc[100000][6];

	cin >> a1000 >> a100 >> a >> db >> b1000 >> b100 >> b >> dc >> c1000 >> c100 >> c;

	dpb[0][0] = a1000;
	dpb[0][1] = a100;
	dpb[0][2] = a;

	dpc[0][0] = a1000;
	dpc[0][1] = a100;
	dpc[0][2] = a;

	int cnt2 = 0, reki = 0;

	for (i = 0; i < 100000; i++) {

		int fbcn1 = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 0, true);
		int fbcn2 = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 0, true);
		int fccn1 = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 0, false);
		int fccn2 = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 0, false);

		//cout << "fbcn1->" << fbcn1 << " fbcn2->" << fbcn2 << " fccn1->" << fccn1 << " fccn2->" << fccn2 << endl;

		if (fbcn1 == 0 && fbcn2 == 0 && fccn1 == 0 && fccn2 == 0) {
			break;
		}
		else if (fbcn1 >= fbcn2 ) {
			dpb[i + 1][0] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 1, true);
			dpb[i + 1][1] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 2, true);
			dpb[i + 1][2] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 3, true);
		}
		else if (fbcn1 < fbcn2) {
			dpb[i + 1][0] = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 1, true);
			dpb[i + 1][1] = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 2, true);
			dpb[i + 1][2] = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 3, true);
		}


		if (fccn1 >= fccn2) {
			dpc[i + 1][0] = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 1, false);
			dpc[i + 1][1] = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 2, false);
			dpc[i + 1][2] = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 3, false);
		}
		else if (fccn1 < fccn2) {
			dpc[i + 1][0] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 1, false);
			dpc[i + 1][1] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 2, false);
			dpc[i + 1][2] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 3, false);
		}

		cnt2++;

	}


	//for (i = 0; i < 100; i++) {

	//	int fbcn = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 0, true);
	//	int fccn = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 0, false);

	//	if (fbcn == 0 && fccn == 0) {
	//		break;
	//	}
	//	
	//	//reki = 1;
	//	//reki = max(fbcn, fccn);

	//	int b0 = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 1, true);
	//	int b1 = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 2, true);
	//	int b2 = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 3, true);
	//	 
	//	int b3 = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 1, true);
	//	int b4 = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 2, true);
	//	int b5 = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 3, true);
	//	 
	//	 
	//	int c0 = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 1, false);
	//	int c1 = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 2, false);
	//	int c2 = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 3, false);
	//	 
	//	int c3 = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 1, false);
	//	int c4 = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 2, false);
	//	int c5 = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 3, false);
	//	
	//	int fdpb1 = funcb(db, b0, b1, b2, 0, true);
	//	int fdpb2 = funcb(db, b3, b4, b5, 0, true);
	//	int fdpb3 = funcb(db, c0, c1, c2, 0, true);
	//	int fdpb4 = funcb(db, c3, c4, c5, 0, true);

	//	int fdpc1 = funcb(dc, b0, b1, b2, 0, false);
	//	int fdpc2 = funcb(dc, b3, b4, b5, 0, false);
	//	int fdpc3 = funcb(dc, c0, c1, c2, 0, false);
	//	int fdpc4 = funcb(dc, c3, c4, c5, 0, false);

	//	cout << fdpb1 << " " << fdpb2 << " " << fdpb3 << " " << fdpb4 << " " << fdpc1 << " " << fdpc2 << " " << fdpc3 << " " << fdpc4 << endl;

	//	if (fdpb1 == 0 && fdpb2 == 0 && fdpb3 == 0 && fdpb4 == 0 && fdpc1 == 0 && fdpc2 == 0 && fdpc3 == 0 && fdpc4 == 0) {
	//		//cnt2 += max(fbcn, fccn) + max({ fdpb1, fdpb2, fdpb3 , fdpb4, fdpc1, fdpc2, fdpc3, fdpc4 });
	//		break;
	//	}

	//	reki = max({ fdpb1, fdpb2, fdpb3 , fdpb4, fdpc1, fdpc2, fdpc3, fdpc4 });

	//	if ( fdpb1 > fdpb2 && fdpb1 > fdpb3 && fdpb1 > fdpb4 ) {
	//		dpb[i + 1][0] = funcb(db, b0, b1, b2, 1, true);
	//		dpb[i + 1][1] = funcb(db, b0, b1, b2, 2, true);
	//		dpb[i + 1][2] = funcb(db, b0, b1, b2, 3, true);
	//	}
	//	else if (fdpb2 > fdpb1 && fdpb2 > fdpb3 && fdpb2 > fdpb4) {
	//		dpb[i + 1][0] = funcb(db, b3, b4, b5, 1, true);
	//		dpb[i + 1][1] = funcb(db, b3, b4, b5, 2, true);
	//		dpb[i + 1][2] = funcb(db, b3, b4, b5, 3, true);
	//	}
	//	else if (fdpb3 > fdpb1 && fdpb3 > fdpb2 && fdpb3 > fdpb4) {
	//		dpb[i + 1][0] = funcb(db, c0, c1, c2, 1, true);
	//		dpb[i + 1][1] = funcb(db, c0, c1, c2, 2, true);
	//		dpb[i + 1][2] = funcb(db, c0, c1, c2, 3, true);
	//	}
	//	else {
	//		dpb[i + 1][0] = funcb(db, c3, c4, c5, 1, true);
	//		dpb[i + 1][1] = funcb(db, c3, c4, c5, 2, true);
	//		dpb[i + 1][2] = funcb(db, c3, c4, c5, 3, true);
	//	}


	//	if (fdpc1 > fdpc2 && fdpc1 > fdpc3 && fdpc1 > fdpc4) {
	//		dpc[i + 1][0] = funcb(dc, b0, b1, b2, 1, false);
	//		dpc[i + 1][1] = funcb(dc, b0, b1, b2, 2, false);
	//		dpc[i + 1][2] = funcb(dc, b0, b1, b2, 3, false);
	//	}
	//	else if (fdpc2 > fdpc1 && fdpc2 > fdpc3 && fdpc2 > fdpc4) {
	//		dpc[i + 1][0] = funcb(dc, b3, b4, b5, 1, false);
	//		dpc[i + 1][1] = funcb(dc, b3, b4, b5, 2, false);
	//		dpc[i + 1][2] = funcb(dc, b3, b4, b5, 3, false);
	//	}
	//	else if (fdpc3 > fdpc1 && fdpc3 > fdpc2 && fdpc3 > fdpc4) {
	//		dpc[i + 1][0] = funcb(dc, c0, c1, c2, 1, false);
	//		dpc[i + 1][1] = funcb(dc, c0, c1, c2, 2, false);
	//		dpc[i + 1][2] = funcb(dc, c0, c1, c2, 3, false);
	//	}
	//	else {
	//		dpc[i + 1][0] = funcb(dc, c3, c4, c5, 1, false);
	//		dpc[i + 1][1] = funcb(dc, c3, c4, c5, 2, false);
	//		dpc[i + 1][2] = funcb(dc, c3, c4, c5, 3, false);
	//	}

	//	cnt2++;

	//}


	//for (i = 0; i < 100000; i++) {

	//	int fbcn = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 0, true);
	//	int fccn = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 0, false);

	//	cout << "fbcn->" << fbcn << " fccn->" << fccn << endl;

	//	if (fbcn == 0 && fccn == 0) {
	//		break;
	//	}
	//	else if (fbcn >= fccn ) {
	//		dpb[i + 1][0] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 1, true);
	//		dpb[i + 1][1] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 2, true);
	//		dpb[i + 1][2] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 3, true);
	//	}
	//	else if (fbcn < fccn) {
	//		dpb[i + 1][0] = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 1, false);
	//		dpb[i + 1][1] = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 2, false);
	//		dpb[i + 1][2] = funcb(db, dpc[i][0], dpc[i][1], dpc[i][2], 3, false);
	//	}


	//	if (fbcn >= fccn) {
	//		dpc[i + 1][0] = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 1, true);
	//		dpc[i + 1][1] = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 2, true);
	//		dpc[i + 1][2] = funcb(dc, dpb[i][0], dpb[i][1], dpb[i][2], 3, true);
	//	}
	//	else if (fbcn < fccn) {
	//		dpc[i + 1][0] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 1, false);
	//		dpc[i + 1][1] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 2, false);
	//		dpc[i + 1][2] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 3, false);
	//	}

	//	cnt2++;

	//}



	cout << cnt2  << endl;








	//int n, d;
	//cin >> n >> d;
	//int dp[110][2];//i日目にjで働く(0:Tokyo,1:Kyoto)
	//			   //初期値の設定
	//dp[0][0] = 0; dp[0][1] = 0;
	//int t, k;
	//cin >> t >> k;
	//dp[1][0] = t; dp[1][1] = k - d;
	//for (int i = 1; i < n; i++) {
	//	//漸化式の計算
	//	int t, k;
	//	cin >> t >> k;
	//	dp[i + 1][0] = max(dp[i][0], dp[i][1] - d) + t;
	//	dp[i + 1][1] = max(dp[i][0] - d, dp[i][1]) + k;

	//	cout << "t->" << dp[i + 1][0] << " k->" << dp[i + 1][1] << endl;

	//}
	//cout << max(dp[n][0], dp[n][1]) << endl;





	getchar();
	getchar();
	return 0;
}