A monster is attacking the Cyberland!

Master Yang, a braver, is going to beat the monster. Yang and the monster each have 3 attributes: hitpoints (HP), offensive power (ATK) and defensive power (DEF).

During the battle, every second the monster's HP decrease by max(0, ATKY - DEFM), while Yang's HP decreases by max(0, ATKM - DEFY), where index Y denotes Master Yang and index M denotes monster. Both decreases happen simultaneously Once monster's HP ≤ 0 and the same time Master Yang's HP > 0, Master Yang wins.

Master Yang can buy attributes from the magic shop of Cyberland: h bitcoins per HP, a bitcoins per ATK, and d bitcoins per DEF.

Now Master Yang wants to know the minimum number of bitcoins he can spend in order to win.

Input

The first line contains three integers HPY, ATKY, DEFY, separated by a space, denoting the initial HP, ATK and DEF of Master Yang.

The second line contains three integers HPM, ATKM, DEFM, separated by a space, denoting the HP, ATK and DEF of the monster.

The third line contains three integers h, a, d, separated by a space, denoting the price of 1 HP, 1 ATK and 1 DEF.

All numbers in input are integer and lie between 1 and 100 inclusively.

Output

The only output line should contain an integer, denoting the minimum bitcoins Master Yang should spend in order to win.

Examples

Input

1 2 1
1 100 1
1 100 100


Output

99


Input

100 100 100
1 1 1
1 1 1


Output

0

Note

For the first sample, prices for ATK and DEF are extremely high. Master Yang can buy 99 HP, then he can beat the monster with 1 HP left.

For the second sample, Master Yang is strong enough to beat the monster, so he doesn't need to buy anything.
import java.io.*;
import java.util.*;

public class Task {
		
	public static void main(String[] args) throws IOException {
		new Task().solve();
	}
	
	PrintWriter out;
	int cnt = 0;
	int n;
	boolean[] used;
	int[] use;
	ArrayList<Integer>[] rg;
	ArrayList<Integer> tsort = new ArrayList<Integer>();
	int[] comp;
	int[] compsize;
	int[] mt;
	int[] a;
	int k;
	boolean[][] g;
	int dp[];
	int m;
	int[] list;
	void solve() throws IOException{
		Reader in = new Reader("input.txt");
		out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
		//out = new PrintWriter(new FileWriter(new File("output.txt"))); 
		
		int hp = in.nextInt();
		int atk = in.nextInt();
		int def = in.nextInt();
		
		int hp2 = in.nextInt();
		int atk2 = in.nextInt();
		int def2 = in.nextInt();
		
		int c1 = in.nextInt();
		int c2 = in.nextInt();
		int c3 = in.nextInt();
		
		int sum = 1000000000;
		
		for (int i = atk; i <= 200; i++) {
			for (int j = def; j < 200; j++) {
				if (i-def2 <= 0)
					continue;
				
				if (atk2-j <= 0) {
					int k = i-atk;
					int l = j-def;
					sum = Math.min(sum, k*c2+l*c3);
					continue;
				}
				
				int k = i-atk;
				int l = j-def;
				int cnt1 = (int) Math.ceil(1D*hp/Math.max(0, atk2-j));
				int cnt2 = (int) Math.ceil(1D*hp2/Math.max(0, i-def2)); 
				int m = 0;
				int cnt = 0;
				int thp = hp;
				while (cnt1 <= cnt2) {
					cnt++;
					thp++;
					cnt1 = (int) Math.ceil(1D*thp/Math.max(0, atk2-j));
				}
				
				sum = Math.min(sum, cnt*c1+k*c2+l*c3);
			}
		}
		
		out.print(sum);
		out.flush();
		out.close();
		
	}
	

	
	long pow(int x, int m) {
		if (m == 0)
			return 1;
		return x*pow(x, m-1);
	}

}
	
	class Pair implements Comparable<Pair> {
		
		int v;
		int z;
		int i;
		
		Pair (int v, int z, int i) {
			this.v = v;
			this.z = z;
			this.i = i;
		}

		@Override
		public int compareTo(Pair p) {
			if (v > p.v)
				return 1;
			if (v < p.v)
				return -1;
			return 0;
		}
		
	}

	class Item implements Comparable<Item> {

		int v;
		int l;
		int z;
		
		Item(int v, int l, int z) {
			this.v = v;
			this.l = l;
			this.z = z;
		}
		
		@Override
		public int compareTo(Item item) {
			
			if (l > item.l)
				return 1;
			else
			if (l < item.l)
				return -1;
			else {
				if (z > item.z)
					return 1;
				else
				if (z < item.z)
					return -1;
				return 0;
			}
						
		}
		
	}
	
	class Reader {
	    
	    StringTokenizer token;
	    BufferedReader in;
	    
	    public Reader(String file) throws IOException {
	        //in = new BufferedReader( new FileReader( file ) );
	        in = new BufferedReader( new InputStreamReader( System.in ) );
	    }
	    
	    public byte nextByte() throws IOException {
	        return Byte.parseByte(Next());
	    }
	    
	    public int nextInt() throws IOException {
	        return Integer.parseInt(Next());
	    }
	    
	    public long nextLong() throws IOException {
	        return Long.parseLong(Next());
	    }
	    
	    public String nextString() throws IOException {
	        return in.readLine();
	    }
	    
	    public String Next() throws IOException {
	        while (token == null || !token.hasMoreTokens()) {
	            token = new StringTokenizer(in.readLine());
	        }
	        return token.nextToken();
	    }

	    
	}

	
