import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 17:52:34 14/09/2020
    Custom Competitive programming helper.
*/
public class Main {
	public static void solve(Reader in, Writer out) {
		int t = in.nextInt();
		while(t-->0) {
			long x = in.nextInt(), y = in.nextInt(), k = in.nextInt();
			long need = k*y+k-1;
			x--;
			out.println((need-1+x)/x + k);
		}
	}

	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

	public Reader() {
		this.br = new BufferedReader(new InputStreamReader(System.in));
	}

	public Reader(String f){
		try {
			this.br = new BufferedReader(new FileReader(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Util{
		private static Random random = new Random();
		static long[] fact;
		public static void initFactorial(int n, long mod) {
			fact = new long[n+1];
			fact[0] = 1;
			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
		}
		public static long modInverse(long a, long MOD) {
			long[] gcdE = gcdExtended(a, MOD);
			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
			long x = gcdE[1];
			return (x % MOD + MOD) % MOD;
		}
		public static long[] gcdExtended(long p, long q) {
			if (q == 0) return new long[] { p, 1, 0 };
			long[] vals = gcdExtended(q, p % q);
			long tmp = vals[2];
			vals[2] = vals[1] - (p / q) * vals[2];
			vals[1] = tmp;
			return vals;
		}
		public static long nCr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nCr(int n, int r) {
			return (fact[n]/fact[r])/fact[n-r];
		}
		public static long nPr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nPr(int n, int r) {
			return fact[n]/fact[n-r];
		}
		public static boolean isPrime(int n) {
	        if (n <= 1) return false;
	        if (n <= 3) return true;
	        if (n % 2 == 0 || n % 3 == 0) return false;
	        for (int i = 5; i * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
	    public static int lowerBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int lowerBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int upperBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static int upperBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	    	int tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static long gcd(long a, long b) {
	    	long tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public Writer(String f){
		try {
			pw = new PrintWriter(new FileWriter(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 17:45:32 14/09/2020
    Custom Competitive programming helper.
*/
public class Main {
	public static void solve(Reader in, Writer out) {
		int t = in.nextInt();
		while(t-->0) {
			long x = in.nextInt(), y = in.nextInt(), k = in.nextInt();

			long needOfSticks = y*k+k-1;
			x--;
			out.println((needOfSticks)/x);
		}
	}

	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

	public Reader() {
		this.br = new BufferedReader(new InputStreamReader(System.in));
	}

	public Reader(String f){
		try {
			this.br = new BufferedReader(new FileReader(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Util{
		private static Random random = new Random();
		static long[] fact;
		public static void initFactorial(int n, long mod) {
			fact = new long[n+1];
			fact[0] = 1;
			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
		}
		public static long modInverse(long a, long MOD) {
			long[] gcdE = gcdExtended(a, MOD);
			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
			long x = gcdE[1];
			return (x % MOD + MOD) % MOD;
		}
		public static long[] gcdExtended(long p, long q) {
			if (q == 0) return new long[] { p, 1, 0 };
			long[] vals = gcdExtended(q, p % q);
			long tmp = vals[2];
			vals[2] = vals[1] - (p / q) * vals[2];
			vals[1] = tmp;
			return vals;
		}
		public static long nCr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nCr(int n, int r) {
			return (fact[n]/fact[r])/fact[n-r];
		}
		public static long nPr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nPr(int n, int r) {
			return fact[n]/fact[n-r];
		}
		public static boolean isPrime(int n) {
	        if (n <= 1) return false;
	        if (n <= 3) return true;
	        if (n % 2 == 0 || n % 3 == 0) return false;
	        for (int i = 5; i * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
	    public static int lowerBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int lowerBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int upperBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static int upperBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	    	int tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static long gcd(long a, long b) {
	    	long tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public Writer(String f){
		try {
			pw = new PrintWriter(new FileWriter(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 17:38:47 14/09/2020
    Custom Competitive programming helper.
*/
public class Main {
	public static void solve(Reader in, Writer out) {
		int t = in.nextInt();
		while(t-->0) {
			long x = in.nextInt(), y = in.nextInt(), k = in.nextInt();

			long needOfSticks = y*k+2*k;
			out.println((needOfSticks+x-1)/x);
		}
	}

	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

	public Reader() {
		this.br = new BufferedReader(new InputStreamReader(System.in));
	}

	public Reader(String f){
		try {
			this.br = new BufferedReader(new FileReader(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Util{
		private static Random random = new Random();
		static long[] fact;
		public static void initFactorial(int n, long mod) {
			fact = new long[n+1];
			fact[0] = 1;
			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
		}
		public static long modInverse(long a, long MOD) {
			long[] gcdE = gcdExtended(a, MOD);
			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
			long x = gcdE[1];
			return (x % MOD + MOD) % MOD;
		}
		public static long[] gcdExtended(long p, long q) {
			if (q == 0) return new long[] { p, 1, 0 };
			long[] vals = gcdExtended(q, p % q);
			long tmp = vals[2];
			vals[2] = vals[1] - (p / q) * vals[2];
			vals[1] = tmp;
			return vals;
		}
		public static long nCr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nCr(int n, int r) {
			return (fact[n]/fact[r])/fact[n-r];
		}
		public static long nPr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nPr(int n, int r) {
			return fact[n]/fact[n-r];
		}
		public static boolean isPrime(int n) {
	        if (n <= 1) return false;
	        if (n <= 3) return true;
	        if (n % 2 == 0 || n % 3 == 0) return false;
	        for (int i = 5; i * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
	    public static int lowerBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int lowerBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int upperBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static int upperBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	    	int tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static long gcd(long a, long b) {
	    	long tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public Writer(String f){
		try {
			pw = new PrintWriter(new FileWriter(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}


// package codeforces;

import java.io.*;
import java.util.*;

public class A {
	static FastReader sc=new FastReader();

	public static void main(String[] args) {
		int t=sc.nextInt();
		while(t-->0) {
			int x=sc.nextInt();
			int y=sc.nextInt();
			int k=sc.nextInt();
			long ans=(long)(y+1)*k;
			ans-=1;
			Double a=Math.ceil(ans/(x-1));
			System.out.println(a.longValue()+k);

		}

	}

	static void print(int a[]) {
		for(int e:a) {
			System.out.print(e+" ");
		}
		System.out.println();
	}
	static int[] readArray(int n) {
		int a[]=new int [n];
		for(int i=0;i<n;i++) {
			a[i]=sc.nextInt();
		}
		return a;
	}
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}


// package codeforces;

import java.io.*;
import java.util.*;

public class A {
	static FastReader sc=new FastReader();

	public static void main(String[] args) {
		int t=sc.nextInt();
		while(t-->0) {
			long x=sc.nextLong();
			long y=sc.nextLong();
			long k=sc.nextLong();
			long ans=(y+1)*k -1;
//			long a=(long)(Math.ceil((double)ans/(x-1)))+k;
			ans= (ans+(x-1)-1)/(x-1)+k;
			System.out.println(ans);

		}

	}

	static void print(int a[]) {
		for(int e:a) {
			System.out.print(e+" ");
		}
		System.out.println();
	}
	static int[] readArray(int n) {
		int a[]=new int [n];
		for(int i=0;i<n;i++) {
			a[i]=sc.nextInt();
		}
		return a;
	}
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}


// package codeforces;

import java.io.*;
import java.util.*;

public class A {
	static FastReader sc=new FastReader();

	public static void main(String[] args) {
		int t=sc.nextInt();
		while(t-->0) {
			int x=sc.nextInt();
			int y=sc.nextInt();
			int k=sc.nextInt();
			long ans=(long)(y+1)*k;
			ans-=1;
			ans=ans/(x-1);
			System.out.println(ans);

		}

	}

	static void print(int a[]) {
		for(int e:a) {
			System.out.print(e+" ");
		}
		System.out.println();
	}
	static int[] readArray(int n) {
		int a[]=new int [n];
		for(int i=0;i<n;i++) {
			a[i]=sc.nextInt();
		}
		return a;
	}
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}


import java.util.*;

public class codechef {
    private static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        int t = 0;
        if (sc.hasNext())
            t = sc.nextInt();
        for (int i = 1; i <= t; i++) {
            solve();
        }
    }

    public static void solve() {
        long a = sc.nextInt();
        long b = sc.nextInt();
        long k = sc.nextInt();
        long reqS = (b + 1) * k - 1 +a - 2;
        System.out.println(reqS / (a - 1) + k);
    }
}


import java.util.*;
public class test {
   public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	int t=sc.nextInt();
	while(t-->0)
	{
	  int x=sc.nextInt();
	  int y=sc.nextInt();
	  int k=sc.nextInt();

	 int trade=(y*k+k-1)/(x-1);
	 if(trade*(x-1)<y*k+k-1)trade++;
	 trade+=k;

	 System.out.println(trade);
	}
	}

}


import java.util.*;
public class test {
   public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	int t=sc.nextInt();
	while(t-->0)
	{
	  long x=sc.nextInt();
	  long y=sc.nextInt();
	  long k=sc.nextInt();

	 long trade=((y*k)+k-1)/(x-1);
	 if(trade*(x-1)<(y*k)+k-1)trade++;
	 trade+=k;

	 System.out.println(trade);
	}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class CF {

    public static void main(String[] args) {
        FastScanner fs=new FastScanner();
        int T=fs.nextInt();
        while (T-- >= 0) {
            long x = fs.nextLong();
            long y = fs.nextLong();
            long k = fs.nextLong();
            long t = (long)(y*k + k - 3 + x)/(x-1);
            System.out.println(t+k);
        }

    }

    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n), temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.StringTokenizer;

public class CF {

    public static void main(String[] args) {
        FastScanner fs=new FastScanner();
        int T=fs.nextInt();
        for (int tt = 0; tt < T; tt++) {

            long x = fs.nextLong();
            long y = fs.nextLong();
            long k = fs.nextLong();
            long t = (long)(y*k + k - 3 + x)/(x-1);
            System.out.println(t+k);
        }

    }

    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n), temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.StringTokenizer;

public class CF {

    public static void main(String[] args) {
        FastScanner fs=new FastScanner();
        int T=fs.nextInt();
        while (T-- >= 0) {
            long x = fs.nextLong();
            long y = fs.nextLong();
            long k = fs.nextLong();
            long t = (long)(y*k + k - 3 + x)/(x-1);
            System.out.println(t+k);
        }

    }

    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n), temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

}


//JAI BAJRANGBALI
import java.util.*;
import java.io.*;
import java.math.BigInteger;
//class Main    //AtCoder
//class Solution // Codechef
public class Solution //Codeforces
{
    public final static int d = 256;
    static int MOD = 1000000007;
    static final float EPSILON = (float)0.01;
    static final double PI = 3.1415926536;
    private static BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
    private static BufferedWriter out = new BufferedWriter (new OutputStreamWriter (System.out));
    static class Graph {
        int V;
        LinkedList<Integer>[] adjListArray;
         Graph(int V) {
            this.V = V;
            adjListArray = new LinkedList[V];
            for(int i = 0; i < V ; i++){
                adjListArray[i] = new LinkedList<Integer>();
            }
        }
        void addEdge( int src, int dest) {
            adjListArray[src].add(dest);
            adjListArray[dest].add(src);
        }

        void DFSUtil(int v, boolean[] visited) {
            visited[v] = true;
            for (int x : adjListArray[v]) {
                if(!visited[x]) DFSUtil(x,visited);
            }

        }
        int connectedComponents() {
            boolean[] visited = new boolean[V];
            int cnt = 0;
            for(int v = 0; v < V; ++v) {
                if(!visited[v] && adjListArray[v].size() != 0) {
                    DFSUtil(v,visited);
                    cnt++;
                }
            }
            return cnt;
        }
    }
    static class SegmentTree{
        int arr[] , st[];
        int maxSize , N;
        SegmentTree(int arr[] , int N){
            this.arr = arr;
            this.N = N;
            int x = (int) (Math.ceil(Math.log(N) / Math.log(2)));
            this.maxSize = 2 * (int) Math.pow(2, x) - 1;
            this.st = new int[maxSize];
            constructST(0 , N-1 , 0);
        }
        void constructST(int start , int end , int ind)
        {
            constructSTUtil(start , end , ind);
        }
        int constructSTUtil(int start , int end , int ind)
        {

            if(start == end){
                st[ind] = arr[start];
                return st[ind];
            }
            else{
                int mid = start + (end - start)/2;
                st[ind] = constructSTUtil(start , mid , (2*ind) + 1) ^ constructSTUtil(mid+1 , end , (2*ind) + 2);
                return st[ind];
            }
        }
        int findXorInRange(int start , int end , int qstart , int qend , int index)
        {
            if(qstart <= start && qend >= end)
            {
                return st[index];
            }
            else if(qstart > end || qend < start || end < start){
                return 0;
            }
            else{
                int mid = start + (end - start)/2;
                return findXorInRange(start , mid , qstart , qend , (2*index) + 1) ^ findXorInRange(mid+1 , end , qstart , qend , (2*index) + 2);
            }
        }
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    static class Cell{
        int X , Y , dis;
        Cell(int x , int y , int di){
            X = x;
            Y = y;
            dis = di;
        }
    }
    static boolean isValid(int x , int y , int N , int M){
        return ((x >= 0 && x < N) &&(y >= 0 && y < M));
    }
    static int searchRabinKarp(String pat, String txt)
    {
        int M = pat.length();
        int N = txt.length();
        int i, j;
        int p = 0; // hash value for pattern
        int t = 0; // hash value for txt
        int h = 1 , cnt = 0;
        int q = 3355439;
        for (i = 0; i < M-1; i++)
            h = (h*d)%q;
        for (i = 0; i < M; i++)
        {
            p = (d*p + pat.charAt(i))%q;
            t = (d*t + txt.charAt(i))%q;
        }
        for (i = 0; i <= N - M; i++)
        {
            if ( p == t )
            {
                for (j = 0; j < M; j++)
                {
                    if (txt.charAt(i+j) != pat.charAt(j))
                        break;
                }
                if (j == M)
                {//System.out.println("Pattern found at index " + i);
                    cnt++;
                }
            }
            if ( i < N-M )
            {
                t = (d*(t - txt.charAt(i)*h) + txt.charAt(i+M))%q;
                if (t < 0)
                    t = (t + q);
            }
        }
        return cnt;
    }
    static long gcd(long bigger , long smaller)
    {
            if (smaller == 0)
                return bigger;
            return gcd(smaller, bigger % smaller);
    }
    static long lcm(long a, long b)
    {
        return (a*b)/gcd(a, b);
    }
    static long sumOfArray(long arr[])
    {
        long sum = 0;
        for(int i = 0 ; i < arr.length ; i++)
            sum += arr[i];
        return sum;
    }
    static boolean isPrime(long n) {
        if(n == 2)
            return true;
        else if(n == 1)
            return false;
        else if (n%2==0)
            return false;
        for(long i=3;i<=Math.sqrt(n);i+=2) {
            if(n%i==0)
                return false;
        }
        return true;
    }
    static long modularExpo(long x, long y, long p)
    {
       long res = 1;
       x = x % p;
       if (x == 0) return 0;
        while (y > 0)
        {
            if((y & 1)==1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }
    static long countDigit(long n)
    {
        return (long)Math.floor(Math.log10(n) + 1);
    }
    static long sumOfDigits(long n)
    {
        long sum;
        for (sum = 0; n > 0; sum += n % 10,n /= 10);
        return sum;
    }
    static boolean isPalindrome(String str)
    {
        int i = 0, j = str.length() - 1;
        while (i < j) {
            if (str.charAt(i) != str.charAt(j))
                return false;
            i++;
            j--;
        }
        return true;
    }
    public static void main(String args[])
    {
        try{
            FastReader sc = new FastReader();
            int T = sc.nextInt();
            while(T-- > 0)
            {
                long x = sc.nextLong();
                long y = sc.nextLong();
                long k = sc.nextLong();
                long ans1 = (k - 1 + (y * k)) / (x - 1);
                if(((k - 1 + (y * k)) % (x - 1)) != 0)
                    ans1 += 1;
                long ans2 = ans1 + k;
                System.out.println(ans2);
            }
            try{
                out.flush();
            }catch(Exception e){
                System.out.print(e);
            };
        }
        catch(Exception e){
            System.out.print(e);
        }
    }
    public static void solve(int N)
    {
        try{

        }catch(Exception e){
            System.out.println("");
        }
    }
}


//JAI BAJRANGBALI
import java.util.*;
import java.io.*;
import java.math.BigInteger;
//class Main    //AtCoder
//class Solution // Codechef
public class Solution //Codeforces
{
    public final static int d = 256;
    static int MOD = 1000000007;
    static final float EPSILON = (float)0.01;
    static final double PI = 3.1415926536;
    private static BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
    private static BufferedWriter out = new BufferedWriter (new OutputStreamWriter (System.out));
    static class Graph {
        int V;
        LinkedList<Integer>[] adjListArray;
         Graph(int V) {
            this.V = V;
            adjListArray = new LinkedList[V];
            for(int i = 0; i < V ; i++){
                adjListArray[i] = new LinkedList<Integer>();
            }
        }
        void addEdge( int src, int dest) {
            adjListArray[src].add(dest);
            adjListArray[dest].add(src);
        }

        void DFSUtil(int v, boolean[] visited) {
            visited[v] = true;
            for (int x : adjListArray[v]) {
                if(!visited[x]) DFSUtil(x,visited);
            }

        }
        int connectedComponents() {
            boolean[] visited = new boolean[V];
            int cnt = 0;
            for(int v = 0; v < V; ++v) {
                if(!visited[v] && adjListArray[v].size() != 0) {
                    DFSUtil(v,visited);
                    cnt++;
                }
            }
            return cnt;
        }
    }
    static class SegmentTree{
        int arr[] , st[];
        int maxSize , N;
        SegmentTree(int arr[] , int N){
            this.arr = arr;
            this.N = N;
            int x = (int) (Math.ceil(Math.log(N) / Math.log(2)));
            this.maxSize = 2 * (int) Math.pow(2, x) - 1;
            this.st = new int[maxSize];
            constructST(0 , N-1 , 0);
        }
        void constructST(int start , int end , int ind)
        {
            constructSTUtil(start , end , ind);
        }
        int constructSTUtil(int start , int end , int ind)
        {

            if(start == end){
                st[ind] = arr[start];
                return st[ind];
            }
            else{
                int mid = start + (end - start)/2;
                st[ind] = constructSTUtil(start , mid , (2*ind) + 1) ^ constructSTUtil(mid+1 , end , (2*ind) + 2);
                return st[ind];
            }
        }
        int findXorInRange(int start , int end , int qstart , int qend , int index)
        {
            if(qstart <= start && qend >= end)
            {
                return st[index];
            }
            else if(qstart > end || qend < start || end < start){
                return 0;
            }
            else{
                int mid = start + (end - start)/2;
                return findXorInRange(start , mid , qstart , qend , (2*index) + 1) ^ findXorInRange(mid+1 , end , qstart , qend , (2*index) + 2);
            }
        }
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    static class Cell{
        int X , Y , dis;
        Cell(int x , int y , int di){
            X = x;
            Y = y;
            dis = di;
        }
    }
    static boolean isValid(int x , int y , int N , int M){
        return ((x >= 0 && x < N) &&(y >= 0 && y < M));
    }
    static int searchRabinKarp(String pat, String txt)
    {
        int M = pat.length();
        int N = txt.length();
        int i, j;
        int p = 0; // hash value for pattern
        int t = 0; // hash value for txt
        int h = 1 , cnt = 0;
        int q = 3355439;
        for (i = 0; i < M-1; i++)
            h = (h*d)%q;
        for (i = 0; i < M; i++)
        {
            p = (d*p + pat.charAt(i))%q;
            t = (d*t + txt.charAt(i))%q;
        }
        for (i = 0; i <= N - M; i++)
        {
            if ( p == t )
            {
                for (j = 0; j < M; j++)
                {
                    if (txt.charAt(i+j) != pat.charAt(j))
                        break;
                }
                if (j == M)
                {//System.out.println("Pattern found at index " + i);
                    cnt++;
                }
            }
            if ( i < N-M )
            {
                t = (d*(t - txt.charAt(i)*h) + txt.charAt(i+M))%q;
                if (t < 0)
                    t = (t + q);
            }
        }
        return cnt;
    }
    static long gcd(long bigger , long smaller)
    {
            if (smaller == 0)
                return bigger;
            return gcd(smaller, bigger % smaller);
    }
    static long lcm(long a, long b)
    {
        return (a*b)/gcd(a, b);
    }
    static long sumOfArray(long arr[])
    {
        long sum = 0;
        for(int i = 0 ; i < arr.length ; i++)
            sum += arr[i];
        return sum;
    }
    static boolean isPrime(long n) {
        if(n == 2)
            return true;
        else if(n == 1)
            return false;
        else if (n%2==0)
            return false;
        for(long i=3;i<=Math.sqrt(n);i+=2) {
            if(n%i==0)
                return false;
        }
        return true;
    }
    static long modularExpo(long x, long y, long p)
    {
       long res = 1;
       x = x % p;
       if (x == 0) return 0;
        while (y > 0)
        {
            if((y & 1)==1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }
    static long countDigit(long n)
    {
        return (long)Math.floor(Math.log10(n) + 1);
    }
    static long sumOfDigits(long n)
    {
        long sum;
        for (sum = 0; n > 0; sum += n % 10,n /= 10);
        return sum;
    }
    static boolean isPalindrome(String str)
    {
        int i = 0, j = str.length() - 1;
        while (i < j) {
            if (str.charAt(i) != str.charAt(j))
                return false;
            i++;
            j--;
        }
        return true;
    }
    public static void main(String args[])
    {
        try{
            FastReader sc = new FastReader();
            int T = sc.nextInt();
            while(T-- > 0)
            {
                long x = sc.nextLong();
                long y = sc.nextLong();
                long k = sc.nextLong();
                long ans1 = (k - 1 + (y * k)) / (x - 1);
                if(((k - 1 + (y * k)) % (x - 1)) == 0)
                    ans1 += 1;
                long ans2 = ans1 + k;
                System.out.println(ans2);
            }
            try{
                out.flush();
            }catch(Exception e){
                System.out.print(e);
            };
        }
        catch(Exception e){
            System.out.print(e);
        }
    }
    public static void solve(int N)
    {
        try{

        }catch(Exception e){
            System.out.println("");
        }
    }
}


//JAI BAJRANGBALI
import java.util.*;
import java.io.*;
import java.math.BigInteger;
//class Main    //AtCoder
//class Solution // Codechef
public class Solution //Codeforces
{
    public final static int d = 256;
    static int MOD = 1000000007;
    static final float EPSILON = (float)0.01;
    static final double PI = 3.1415926536;
    private static BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
    private static BufferedWriter out = new BufferedWriter (new OutputStreamWriter (System.out));
    static class Graph {
        int V;
        LinkedList<Integer>[] adjListArray;
         Graph(int V) {
            this.V = V;
            adjListArray = new LinkedList[V];
            for(int i = 0; i < V ; i++){
                adjListArray[i] = new LinkedList<Integer>();
            }
        }
        void addEdge( int src, int dest) {
            adjListArray[src].add(dest);
            adjListArray[dest].add(src);
        }

        void DFSUtil(int v, boolean[] visited) {
            visited[v] = true;
            for (int x : adjListArray[v]) {
                if(!visited[x]) DFSUtil(x,visited);
            }

        }
        int connectedComponents() {
            boolean[] visited = new boolean[V];
            int cnt = 0;
            for(int v = 0; v < V; ++v) {
                if(!visited[v] && adjListArray[v].size() != 0) {
                    DFSUtil(v,visited);
                    cnt++;
                }
            }
            return cnt;
        }
    }
    static class SegmentTree{
        int arr[] , st[];
        int maxSize , N;
        SegmentTree(int arr[] , int N){
            this.arr = arr;
            this.N = N;
            int x = (int) (Math.ceil(Math.log(N) / Math.log(2)));
            this.maxSize = 2 * (int) Math.pow(2, x) - 1;
            this.st = new int[maxSize];
            constructST(0 , N-1 , 0);
        }
        void constructST(int start , int end , int ind)
        {
            constructSTUtil(start , end , ind);
        }
        int constructSTUtil(int start , int end , int ind)
        {

            if(start == end){
                st[ind] = arr[start];
                return st[ind];
            }
            else{
                int mid = start + (end - start)/2;
                st[ind] = constructSTUtil(start , mid , (2*ind) + 1) ^ constructSTUtil(mid+1 , end , (2*ind) + 2);
                return st[ind];
            }
        }
        int findXorInRange(int start , int end , int qstart , int qend , int index)
        {
            if(qstart <= start && qend >= end)
            {
                return st[index];
            }
            else if(qstart > end || qend < start || end < start){
                return 0;
            }
            else{
                int mid = start + (end - start)/2;
                return findXorInRange(start , mid , qstart , qend , (2*index) + 1) ^ findXorInRange(mid+1 , end , qstart , qend , (2*index) + 2);
            }
        }
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    static class Cell{
        int X , Y , dis;
        Cell(int x , int y , int di){
            X = x;
            Y = y;
            dis = di;
        }
    }
    static boolean isValid(int x , int y , int N , int M){
        return ((x >= 0 && x < N) &&(y >= 0 && y < M));
    }
    static int searchRabinKarp(String pat, String txt)
    {
        int M = pat.length();
        int N = txt.length();
        int i, j;
        int p = 0; // hash value for pattern
        int t = 0; // hash value for txt
        int h = 1 , cnt = 0;
        int q = 3355439;
        for (i = 0; i < M-1; i++)
            h = (h*d)%q;
        for (i = 0; i < M; i++)
        {
            p = (d*p + pat.charAt(i))%q;
            t = (d*t + txt.charAt(i))%q;
        }
        for (i = 0; i <= N - M; i++)
        {
            if ( p == t )
            {
                for (j = 0; j < M; j++)
                {
                    if (txt.charAt(i+j) != pat.charAt(j))
                        break;
                }
                if (j == M)
                {//System.out.println("Pattern found at index " + i);
                    cnt++;
                }
            }
            if ( i < N-M )
            {
                t = (d*(t - txt.charAt(i)*h) + txt.charAt(i+M))%q;
                if (t < 0)
                    t = (t + q);
            }
        }
        return cnt;
    }
    static long gcd(long bigger , long smaller)
    {
            if (smaller == 0)
                return bigger;
            return gcd(smaller, bigger % smaller);
    }
    static long lcm(long a, long b)
    {
        return (a*b)/gcd(a, b);
    }
    static long sumOfArray(long arr[])
    {
        long sum = 0;
        for(int i = 0 ; i < arr.length ; i++)
            sum += arr[i];
        return sum;
    }
    static boolean isPrime(long n) {
        if(n == 2)
            return true;
        else if(n == 1)
            return false;
        else if (n%2==0)
            return false;
        for(long i=3;i<=Math.sqrt(n);i+=2) {
            if(n%i==0)
                return false;
        }
        return true;
    }
    static long modularExpo(long x, long y, long p)
    {
       long res = 1;
       x = x % p;
       if (x == 0) return 0;
        while (y > 0)
        {
            if((y & 1)==1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }
    static long countDigit(long n)
    {
        return (long)Math.floor(Math.log10(n) + 1);
    }
    static long sumOfDigits(long n)
    {
        long sum;
        for (sum = 0; n > 0; sum += n % 10,n /= 10);
        return sum;
    }
    static boolean isPalindrome(String str)
    {
        int i = 0, j = str.length() - 1;
        while (i < j) {
            if (str.charAt(i) != str.charAt(j))
                return false;
            i++;
            j--;
        }
        return true;
    }
    public static void main(String args[])
    {
        try{
            FastReader sc = new FastReader();
            int T = sc.nextInt();
            while(T-- > 0)
            {
                long x = sc.nextLong();
                long y = sc.nextLong();
                long k = sc.nextLong();
                long ans1 = (long)(Math.ceil((Double.valueOf(k-1) + Double.valueOf(y * k))/Double.valueOf(x - 1)));
                long ans2 = ans1 + k;
                System.out.println(ans2);
            }
            try{
                out.flush();
            }catch(Exception e){
                System.out.print(e);
            };
        }
        catch(Exception e){
            System.out.print(e);
        }
    }
    public static void solve(int N)
    {
        try{

        }catch(Exception e){
            System.out.println("");
        }
    }
}


//JAI BAJRANGBALI
import java.util.*;
import java.io.*;
import java.math.BigInteger;
//class Main    //AtCoder
//class Solution // Codechef
public class Solution //Codeforces
{
    public final static int d = 256;
    static int MOD = 1000000007;
    static final float EPSILON = (float)0.01;
    static final double PI = 3.1415926536;
    private static BufferedReader in = new BufferedReader (new InputStreamReader (System.in));
    private static BufferedWriter out = new BufferedWriter (new OutputStreamWriter (System.out));
    static class Graph {
        int V;
        LinkedList<Integer>[] adjListArray;
         Graph(int V) {
            this.V = V;
            adjListArray = new LinkedList[V];
            for(int i = 0; i < V ; i++){
                adjListArray[i] = new LinkedList<Integer>();
            }
        }
        void addEdge( int src, int dest) {
            adjListArray[src].add(dest);
            adjListArray[dest].add(src);
        }

        void DFSUtil(int v, boolean[] visited) {
            visited[v] = true;
            for (int x : adjListArray[v]) {
                if(!visited[x]) DFSUtil(x,visited);
            }

        }
        int connectedComponents() {
            boolean[] visited = new boolean[V];
            int cnt = 0;
            for(int v = 0; v < V; ++v) {
                if(!visited[v] && adjListArray[v].size() != 0) {
                    DFSUtil(v,visited);
                    cnt++;
                }
            }
            return cnt;
        }
    }
    static class SegmentTree{
        int arr[] , st[];
        int maxSize , N;
        SegmentTree(int arr[] , int N){
            this.arr = arr;
            this.N = N;
            int x = (int) (Math.ceil(Math.log(N) / Math.log(2)));
            this.maxSize = 2 * (int) Math.pow(2, x) - 1;
            this.st = new int[maxSize];
            constructST(0 , N-1 , 0);
        }
        void constructST(int start , int end , int ind)
        {
            constructSTUtil(start , end , ind);
        }
        int constructSTUtil(int start , int end , int ind)
        {

            if(start == end){
                st[ind] = arr[start];
                return st[ind];
            }
            else{
                int mid = start + (end - start)/2;
                st[ind] = constructSTUtil(start , mid , (2*ind) + 1) ^ constructSTUtil(mid+1 , end , (2*ind) + 2);
                return st[ind];
            }
        }
        int findXorInRange(int start , int end , int qstart , int qend , int index)
        {
            if(qstart <= start && qend >= end)
            {
                return st[index];
            }
            else if(qstart > end || qend < start || end < start){
                return 0;
            }
            else{
                int mid = start + (end - start)/2;
                return findXorInRange(start , mid , qstart , qend , (2*index) + 1) ^ findXorInRange(mid+1 , end , qstart , qend , (2*index) + 2);
            }
        }
    }

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    static class Cell{
        int X , Y , dis;
        Cell(int x , int y , int di){
            X = x;
            Y = y;
            dis = di;
        }
    }
    static boolean isValid(int x , int y , int N , int M){
        return ((x >= 0 && x < N) &&(y >= 0 && y < M));
    }
    static int searchRabinKarp(String pat, String txt)
    {
        int M = pat.length();
        int N = txt.length();
        int i, j;
        int p = 0; // hash value for pattern
        int t = 0; // hash value for txt
        int h = 1 , cnt = 0;
        int q = 3355439;
        for (i = 0; i < M-1; i++)
            h = (h*d)%q;
        for (i = 0; i < M; i++)
        {
            p = (d*p + pat.charAt(i))%q;
            t = (d*t + txt.charAt(i))%q;
        }
        for (i = 0; i <= N - M; i++)
        {
            if ( p == t )
            {
                for (j = 0; j < M; j++)
                {
                    if (txt.charAt(i+j) != pat.charAt(j))
                        break;
                }
                if (j == M)
                {//System.out.println("Pattern found at index " + i);
                    cnt++;
                }
            }
            if ( i < N-M )
            {
                t = (d*(t - txt.charAt(i)*h) + txt.charAt(i+M))%q;
                if (t < 0)
                    t = (t + q);
            }
        }
        return cnt;
    }
    static long gcd(long bigger , long smaller)
    {
            if (smaller == 0)
                return bigger;
            return gcd(smaller, bigger % smaller);
    }
    static long lcm(long a, long b)
    {
        return (a*b)/gcd(a, b);
    }
    static long sumOfArray(long arr[])
    {
        long sum = 0;
        for(int i = 0 ; i < arr.length ; i++)
            sum += arr[i];
        return sum;
    }
    static boolean isPrime(long n) {
        if(n == 2)
            return true;
        else if(n == 1)
            return false;
        else if (n%2==0)
            return false;
        for(long i=3;i<=Math.sqrt(n);i+=2) {
            if(n%i==0)
                return false;
        }
        return true;
    }
    static long modularExpo(long x, long y, long p)
    {
       long res = 1;
       x = x % p;
       if (x == 0) return 0;
        while (y > 0)
        {
            if((y & 1)==1)
                res = (res * x) % p;
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }
    static long countDigit(long n)
    {
        return (long)Math.floor(Math.log10(n) + 1);
    }
    static long sumOfDigits(long n)
    {
        long sum;
        for (sum = 0; n > 0; sum += n % 10,n /= 10);
        return sum;
    }
    static boolean isPalindrome(String str)
    {
        int i = 0, j = str.length() - 1;
        while (i < j) {
            if (str.charAt(i) != str.charAt(j))
                return false;
            i++;
            j--;
        }
        return true;
    }
    public static void main(String args[])
    {
        try{
            FastReader sc = new FastReader();
            int T = sc.nextInt();
            while(T-- > 0)
            {
                long x = sc.nextLong();
                long y = sc.nextLong();
                long k = sc.nextLong();
                long ans1 = (k - 1 + (y * k)) / (x - 1);
                if(((k - 1 + (y * k)) % (x - 1)) == 0)
                    ans1 += 1
                long ans2 = ans1 + k;
                System.out.println(ans2);
            }
            try{
                out.flush();
            }catch(Exception e){
                System.out.print(e);
            };
        }
        catch(Exception e){
            System.out.print(e);
        }
    }
    public static void solve(int N)
    {
        try{

        }catch(Exception e){
            System.out.println("");
        }
    }
}


// package CompetetiveCoding;
import java.io.*;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;

public class Educational_Codeforces_Round_95_A {
	static class Reader
	  {
	      final private int BUFFER_SIZE = 1 << 16;
	      private DataInputStream din;
	      private byte[] buffer;
	      private int bufferPointer, bytesRead;

	      public Reader()
	      {
	          din = new DataInputStream(System.in);
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public Reader(String file_name) throws IOException
	      {
	          din = new DataInputStream(new FileInputStream(file_name));
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public String readLine() throws IOException
	      {
	          byte[] buf = new byte[64]; // line length
	          int cnt = 0, c;
	          while ((c = read()) != -1)
	          {
	              if (c == '\n')
	                  break;
	              buf[cnt++] = (byte) c;
	          }
	          return new String(buf, 0, cnt);
	      }

	      public int nextInt() throws IOException
	      {
	          int ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do
	          {
	              ret = ret * 10 + c - '0';
	          }  while ((c = read()) >= '0' && c <= '9');

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public long nextLong() throws IOException
	      {
	          long ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');
	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public double nextDouble() throws IOException
	      {
	          double ret = 0, div = 1;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();

	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');

	          if (c == '.')
	          {
	              while ((c = read()) >= '0' && c <= '9')
	              {
	                  ret += (c - '0') / (div *= 10);
	              }
	          }

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      private void fillBuffer() throws IOException
	      {
	          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
	          if (bytesRead == -1)
	              buffer[0] = -1;
	      }

	      private byte read() throws IOException
	      {
	          if (bufferPointer == bytesRead)
	              fillBuffer();
	          return buffer[bufferPointer++];
	      }

	      public void close() throws IOException
	      {
	          if (din == null)
	              return;
	          din.close();
	      }
	  }
		static Reader br=new Reader();

		public static void main(String[] args)throws IOException {

			int t=br.nextInt();
			for(int i=0;i<t;i++)
			{
				solve();
			}

		}
		public static long round(double x,double y,double k) {
			long sol;
			if((((k*y)+k)-x)%(x-1)!=0) {
				sol=(long)(Math.floor((((k*y)+k)-x)/(x-1)));
			}
			else
			{
				sol=(long)((((k*y)+k)-x)/(x-1));
			}
			return sol;
		}
		public static void solve()throws IOException {
			long x=br.nextInt();
			long y=br.nextInt();
			long k=br.nextInt();
			long sticks=(k*y)+k;
			sticks-=1;
			long sol=(long)((sticks)/(x-1));
			if(sticks%(x-1)!=0)
				sol+=1;
			System.out.println(sol+k);

		}

}


// package CompetetiveCoding;
import java.io.*;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;

public class Educational_Codeforces_Round_95_A {
	static class Reader
	  {
	      final private int BUFFER_SIZE = 1 << 16;
	      private DataInputStream din;
	      private byte[] buffer;
	      private int bufferPointer, bytesRead;

	      public Reader()
	      {
	          din = new DataInputStream(System.in);
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public Reader(String file_name) throws IOException
	      {
	          din = new DataInputStream(new FileInputStream(file_name));
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public String readLine() throws IOException
	      {
	          byte[] buf = new byte[64]; // line length
	          int cnt = 0, c;
	          while ((c = read()) != -1)
	          {
	              if (c == '\n')
	                  break;
	              buf[cnt++] = (byte) c;
	          }
	          return new String(buf, 0, cnt);
	      }

	      public int nextInt() throws IOException
	      {
	          int ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do
	          {
	              ret = ret * 10 + c - '0';
	          }  while ((c = read()) >= '0' && c <= '9');

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public long nextLong() throws IOException
	      {
	          long ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');
	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public double nextDouble() throws IOException
	      {
	          double ret = 0, div = 1;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();

	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');

	          if (c == '.')
	          {
	              while ((c = read()) >= '0' && c <= '9')
	              {
	                  ret += (c - '0') / (div *= 10);
	              }
	          }

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      private void fillBuffer() throws IOException
	      {
	          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
	          if (bytesRead == -1)
	              buffer[0] = -1;
	      }

	      private byte read() throws IOException
	      {
	          if (bufferPointer == bytesRead)
	              fillBuffer();
	          return buffer[bufferPointer++];
	      }

	      public void close() throws IOException
	      {
	          if (din == null)
	              return;
	          din.close();
	      }
	  }
		static Reader br=new Reader();

		public static void main(String[] args)throws IOException {

			int t=br.nextInt();
			for(int i=0;i<t;i++)
			{
				solve();
			}

		}
		public static long round(double x,double y,double k) {
			long sol;
			if((((k*y)+k)-x)%(x-1)!=0) {
				sol=(long)(Math.floor((((k*y)+k)-x)/(x-1)));
			}
			else
			{
				sol=(long)((((k*y)+k)-x)/(x-1));
			}
			return sol;
		}
		public static void solve()throws IOException {
			long x=br.nextInt();
			long y=br.nextInt();
			long k=br.nextInt();
			long sol=(long)(((k*y)+k)-x)/(x-1);
			sol+=1+k;
			if((sol-k-1)<(((k*y)+k)-x)/(x-1.0))sol++;
			System.out.println(sol);

		}

}


// package CompetetiveCoding;
import java.io.*;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;

public class Educational_Codeforces_Round_95_A {
	static class Reader
	  {
	      final private int BUFFER_SIZE = 1 << 16;
	      private DataInputStream din;
	      private byte[] buffer;
	      private int bufferPointer, bytesRead;

	      public Reader()
	      {
	          din = new DataInputStream(System.in);
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public Reader(String file_name) throws IOException
	      {
	          din = new DataInputStream(new FileInputStream(file_name));
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public String readLine() throws IOException
	      {
	          byte[] buf = new byte[64]; // line length
	          int cnt = 0, c;
	          while ((c = read()) != -1)
	          {
	              if (c == '\n')
	                  break;
	              buf[cnt++] = (byte) c;
	          }
	          return new String(buf, 0, cnt);
	      }

	      public int nextInt() throws IOException
	      {
	          int ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do
	          {
	              ret = ret * 10 + c - '0';
	          }  while ((c = read()) >= '0' && c <= '9');

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public long nextLong() throws IOException
	      {
	          long ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');
	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public double nextDouble() throws IOException
	      {
	          double ret = 0, div = 1;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();

	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');

	          if (c == '.')
	          {
	              while ((c = read()) >= '0' && c <= '9')
	              {
	                  ret += (c - '0') / (div *= 10);
	              }
	          }

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      private void fillBuffer() throws IOException
	      {
	          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
	          if (bytesRead == -1)
	              buffer[0] = -1;
	      }

	      private byte read() throws IOException
	      {
	          if (bufferPointer == bytesRead)
	              fillBuffer();
	          return buffer[bufferPointer++];
	      }

	      public void close() throws IOException
	      {
	          if (din == null)
	              return;
	          din.close();
	      }
	  }
		static Reader br=new Reader();

		public static void main(String[] args)throws IOException {

			int t=br.nextInt();
			for(int i=0;i<t;i++)
			{
				solve();
			}

		}
		public static long round(double x,double y,double k) {
			long sol;
			if((((k*y)+k)-x)%(x-1)!=0) {
				sol=(long)(Math.floor((((k*y)+k)-x)/(x-1)));
			}
			else
			{
				sol=(long)((((k*y)+k)-x)/(x-1));
			}
			return sol;
		}
		public static void solve()throws IOException {
			long x=br.nextInt();
			long y=br.nextInt();
			long k=br.nextInt();

//	        System.out.println(df.format(num));
			long sol=(long)(((k*y)+k)-x)/(x-1);
			sol+=1+k;
			if((((k*y)+k)-x)%(x-1)!=0)sol++;
			System.out.println(sol);
		}

}


// package CompetetiveCoding;
import java.io.*;
import java.util.*;

public class Educational_Codeforces_Round_95_A {
	static class Reader
	  {
	      final private int BUFFER_SIZE = 1 << 16;
	      private DataInputStream din;
	      private byte[] buffer;
	      private int bufferPointer, bytesRead;

	      public Reader()
	      {
	          din = new DataInputStream(System.in);
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public Reader(String file_name) throws IOException
	      {
	          din = new DataInputStream(new FileInputStream(file_name));
	          buffer = new byte[BUFFER_SIZE];
	          bufferPointer = bytesRead = 0;
	      }

	      public String readLine() throws IOException
	      {
	          byte[] buf = new byte[64]; // line length
	          int cnt = 0, c;
	          while ((c = read()) != -1)
	          {
	              if (c == '\n')
	                  break;
	              buf[cnt++] = (byte) c;
	          }
	          return new String(buf, 0, cnt);
	      }

	      public int nextInt() throws IOException
	      {
	          int ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do
	          {
	              ret = ret * 10 + c - '0';
	          }  while ((c = read()) >= '0' && c <= '9');

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public long nextLong() throws IOException
	      {
	          long ret = 0;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();
	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');
	          if (neg)
	              return -ret;
	          return ret;
	      }

	      public double nextDouble() throws IOException
	      {
	          double ret = 0, div = 1;
	          byte c = read();
	          while (c <= ' ')
	              c = read();
	          boolean neg = (c == '-');
	          if (neg)
	              c = read();

	          do {
	              ret = ret * 10 + c - '0';
	          }
	          while ((c = read()) >= '0' && c <= '9');

	          if (c == '.')
	          {
	              while ((c = read()) >= '0' && c <= '9')
	              {
	                  ret += (c - '0') / (div *= 10);
	              }
	          }

	          if (neg)
	              return -ret;
	          return ret;
	      }

	      private void fillBuffer() throws IOException
	      {
	          bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
	          if (bytesRead == -1)
	              buffer[0] = -1;
	      }

	      private byte read() throws IOException
	      {
	          if (bufferPointer == bytesRead)
	              fillBuffer();
	          return buffer[bufferPointer++];
	      }

	      public void close() throws IOException
	      {
	          if (din == null)
	              return;
	          din.close();
	      }
	  }
		static Reader br=new Reader();

		public static void main(String[] args)throws IOException {

			int t=br.nextInt();
			for(int i=0;i<t;i++)
			{
				solve();
			}

		}
		public static void solve()throws IOException {
			long x=br.nextInt();
			long y=br.nextInt();
			long k=br.nextInt();
			long sol=(long)((((k*y)+k)-x)/(x-1));
			sol+=1;
			System.out.println(sol);
		}

}


import java.io.*;
import java.util.*;
import java.lang.*;

public class Main{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class Task {
        public long ceil(long a, long b){
            return (a-1)/(b)+1;
        }
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long x = in.nextLong();
            long y = in.nextLong();
            long k = in.nextLong();
            long need = k+y*k-1;
            long ans = (need <= 0 ? 0 : ceil(need, x-1)+k);
            out.println(ans);
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
        double nextDouble() { return Double.parseDouble(next()); }

        String nextLine() {
            String str = "";
            try { str = reader.readLine(); }
            catch (IOException e) { e.printStackTrace(); }
            return str;
        }

    }
}


import java.io.*;
import java.util.*;
import java.lang.*;

public class Main{
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        int testCount = Integer.parseInt(in.next());
        for (int i = 1; i <= testCount; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class Task {
        public long ceil(long a, long b){
            return (a-1)/(b)+1;
        }
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long x = in.nextLong();
            long y = in.nextLong();
            long k = in.nextLong();
            long need = k+y*k;
            long ans = (need <= x ? 0 : ceil(need-x, x-1)+k);
            out.println(ans+1);
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
        double nextDouble() { return Double.parseDouble(next()); }

        String nextLine() {
            String str = "";
            try { str = reader.readLine(); }
            catch (IOException e) { e.printStackTrace(); }
            return str;
        }

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class CFBuyingTorchesA {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    static StringBuilder ans = new StringBuilder();

    public static void main(String[] args) throws IOException {
        try {
            long startTime = System.currentTimeMillis();
            long[] inputarr;
            for (int test = Integer.parseInt(br.readLine()); test > 0; test--) {
                inputarr = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::valueOf).toArray();
                solution(inputarr[0], inputarr[1], inputarr[2]);
            }
            System.out.print(ans);
            long endTime = System.currentTimeMillis();
            // System.out.println("Time:" + (endTime - startTime) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void solution(long x, long y, long k) {
        long countMoves = 0;
        long totalSticks = k * y + k;

        if (totalSticks - x > 0) {
            if ( (totalSticks - x) % (x - 1) == 0) {
                countMoves = k + 1 + (totalSticks - x)/ (x - 1);
            } else {
                countMoves = k + 1 + (totalSticks - x)/ (x - 1) + 1;
            }
        } else {
            countMoves = k + 1;
        }

        ans.append(countMoves);
        ans.append('\n');
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class CFBuyingTorchesA {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    static StringBuilder ans = new StringBuilder();

    public static void main(String[] args) throws IOException {
        try {
            long startTime = System.currentTimeMillis();
            long[] inputarr;
            for (int test = Integer.parseInt(br.readLine()); test > 0; test--) {
                inputarr = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::valueOf).toArray();
                solution(inputarr[0], inputarr[1], inputarr[2]);
            }
            System.out.print(ans);
            long endTime = System.currentTimeMillis();
            // System.out.println("Time:" + (endTime - startTime) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void solution(long x, long y, long k) {
        long countMoves = (long) Math.ceil(k + ((k * y) + k - 1.0) / (x - 1.0));

        ans.append(countMoves);
        ans.append('\n');
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class CFBuyingTorchesA {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    static StringBuilder ans = new StringBuilder();

    public static void main(String[] args) throws IOException {
        try {
            long startTime = System.currentTimeMillis();
            long[] inputarr;
            for (int test = Integer.parseInt(br.readLine()); test > 0; test--) {
                inputarr = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::valueOf).toArray();
                solution(inputarr[0], inputarr[1], inputarr[2]);
            }
            System.out.print(ans);
            long endTime = System.currentTimeMillis();
            // System.out.println("Time:" + (endTime - startTime) + "ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void solution(long x, long y, long k) {
        long countMoves = 0;
        long totalSticks = k * y + k;

        if ( (totalSticks - x) % (x - 1) == 0) {
            countMoves = k + 1 + (totalSticks - x)/ (x - 1);
        } else {
            countMoves = k + 1 + (totalSticks - x)/ (x - 1) + 1;
        }

        // countMoves = k + 1 + ((totalSticks - x) + (x - 1) + 1)/ (x - 1);

        ans.append(countMoves);
        ans.append('\n');
    }
}


import java.io.*;
import java.util.*;

public class Solution {

    public static void main (String[] args)
    {
    	Scanner sc=new Scanner(System.in);
    	int t=sc.nextInt();
    	for(int ii=0;ii<t;ii++) {
    	long arr[]=new long [3];
    	for(int i=0;i<3;i++) {
    	     arr[i]=sc.nextInt();

    	}
    	long x=arr[2]*arr[1]+arr[2]-1;
    	long count=0;

    	count =x/(arr[0]-1);
    	if(x%(arr[0]-1)==0) {

    	}
    	else {
    		count++;
    	}

    	count=count+arr[2];
    	System.out.println(count);

    	}
    }
}


import java.io.*;
import java.util.*;

public class Solution {

    public static void main (String[] args)
    {
    	Scanner sc=new Scanner(System.in);
    	int t=sc.nextInt();
    	for(int ii=0;ii<t;ii++) {
    	long arr[]=new long [3];
    	for(int i=0;i<3;i++) {
    	     arr[i]=sc.nextInt();

    	}
    	long x=arr[2]*arr[1]+arr[2]-1;
    	long count=0;

    	count =x/(arr[0]-1);
    	if(x%(arr[0]-1)==0) {

    	}
    	else {
    		count++;
    	}
    	if(x%arr[0]==0) {
    		count--;
    	}

    	count=count+arr[2];
    	System.out.println(count);

    	}
    }
}


import java.util.*;
public class torches {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int testcase = scanner.nextInt();
        while(testcase != 0){
            long x = scanner.nextLong();
            long y = scanner.nextLong();
            long k = scanner.nextLong();
            long stick = 1;
            long counter = 0;

            counter = (k+(k*y)-1)/(x-stick);

             if((k+(k*y)-1)%(x-stick) != 0){
                 counter = counter + 1;
             }
            counter = counter + k;
            System.out.println(counter);
         testcase--;
        }
    }
}


import java.util.*;
public class torches {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int testcase = scanner.nextInt();
        while(testcase != 0){
            long x = scanner.nextLong();
            long y = scanner.nextLong();
            long k = scanner.nextLong();
            long stick = 1;
            long counter = 0;
            long z = (k)+(k*y);
            counter = (k+(k*y)-(stick))/(x-stick);
            counter = counter + k;
            System.out.println(counter);
         testcase--;
        }
    }
}