#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];

	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;

	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);

		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(dc, dpc[i][0], dpc[i][1], dpc[i][2], 1, false);
			dpb[i + 1][1] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 2, false);
			dpb[i + 1][2] = funcb(dc, dpc[i][0], dpc[i][1], dpc[i][2], 3, false);
		}


		if (fbcn >= fccn) {
			dpc[i + 1][0] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 1, true);
			dpc[i + 1][1] = funcb(db, dpb[i][0], dpb[i][1], dpb[i][2], 2, true);
			dpc[i + 1][2] = funcb(db, 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;
}