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);
            while(stick < z){
              stick = stick + (x-1);
              counter++;
            }
            counter = counter + k;
            System.out.println(counter);
         testcase--;
        }
    }
}


import java.util.ArrayList;
import java.util.Scanner;

public class main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int tests = Integer.valueOf(scanner.nextLine());
        ArrayList<Long> arrayList = new ArrayList();
        for (int i = 0; i < tests; i++) {
            arrayList = stringtolong(scanner.nextLine());
            doit(arrayList.get(0), arrayList.get(1), arrayList.get(2));
        }
    }

    private static ArrayList<Long> stringtolong(String a) {
        ArrayList<Long> arrayList = new ArrayList();
        int first = a.indexOf(" ");
        int secound = a.indexOf(" ", first + 1);
        arrayList.add(Long.valueOf(a.substring(0, first)));
        arrayList.add(Long.valueOf(a.substring(first + 1, secound)));
        arrayList.add(Long.valueOf(a.substring(secound + 1)));
        return arrayList;
    }

    private static void doit(long x, long y, long k) {
        long n = ((k + (y * k) - 1) / (x - 1)) + k;
        if ((k + (y * k) - 1) % (x - 1) != 0) {
            System.out.println(n + 1);
        } else {
            System.out.println(n);
        }
    }
}


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

public class Main {

    public static void main(String[] args) {
        Problems problems = new Problems();
        problems.solve();
    }
}

class Problems {

    Parser parser = new Parser();

    void solve() {
        int t = parser.parseInt();
        for (int i = 0; i < t; i++) {
            Problem problem = new Problem();
            problem.solve();
        }
    }

    class Problem {

        void solve() {
            long x = parser.parseInt();
            long y = parser.parseInt();
            long k = parser.parseInt();

            x -= 1;
            long n = k * y + k - 1;

            System.out.println((n + x - 1) / x + k);
        }
    }
}

class Parser {
    private final Iterator<String> stringIterator;
    private final Deque<String> inputs;

    Parser() {
        this(System.in);
    }

    Parser(InputStream in) {
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        stringIterator = br.lines().iterator();
        inputs = new ArrayDeque<>();
    }

    void fill() {
        while (inputs.isEmpty()) {
            if (!stringIterator.hasNext()) throw new NoSuchElementException();
            inputs.addAll(Arrays.asList(stringIterator.next().split(" ")));
            while (!inputs.isEmpty() && inputs.getFirst().isEmpty()) {
                inputs.removeFirst();
            }
        }
    }

    Integer parseInt() {
        fill();
        if (!inputs.isEmpty()) {
            return Integer.parseInt(inputs.pollFirst());
        }
        throw new NoSuchElementException();
    }

    Long parseLong() {
        fill();
        if (!inputs.isEmpty()) {
            return Long.parseLong(inputs.pollFirst());
        }
        throw new NoSuchElementException();
    }

    Double parseDouble() {
        fill();
        if (!inputs.isEmpty()) {
            return Double.parseDouble(inputs.pollFirst());
        }
        throw new NoSuchElementException();
    }

    String parseString() {
        fill();
        return inputs.removeFirst();
    }
}


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

		long k=sc.nextLong();
		long res;
		res=k+div(k+k*y-1,x-1);
		System.out.println(res);

		}
	}
	public static long div(long a,long b){
		return (a+b-1)/b;
	}
}


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

// https://codeforces.com/contest/1418/problem/A

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Problem solver = new Problem();
        int numberTest = in.nextInt();
        solver.solve(numberTest, in, out);
        out.close();
    }

    static class Problem {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            while (testNumber > 0) {
                int x = in.nextInt();
                int y = in.nextInt();
                int k = in.nextInt();
                int need = k * (y + 1) - 1;
                int answer = (need + (x - 2)) / (x - 1) + k;
                out.println(answer);
                testNumber--;
            }
        }
    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(String fileName) throws FileNotFoundException {
            super(fileName);
        }

        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

    }

    static class InputReader {
        BufferedReader br;
        StringTokenizer in;

        public InputReader(String fileName) {
            try {
                br = new BufferedReader(new FileReader(fileName));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public InputReader(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
        }

        boolean hasMoreTokens() {
            while (in == null || !in.hasMoreTokens()) {
                String s = nextLine();
                if (s == null) {
                    return false;
                }
                in = new StringTokenizer(s);
            }
            return true;
        }

        public String nextString() {
            return hasMoreTokens() ? in.nextToken() : null;
        }

        public String nextLine() {
            try {
                in = null;
                return br.readLine();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

        public int nextInt() {
            return Integer.parseInt(nextString());
        }

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

    }
}


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

// https://codeforces.com/contest/1418/problem/A

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Problem solver = new Problem();
        int numberTest = in.nextInt();
        solver.solve(numberTest, in, out);
        out.close();
    }

    static class Problem {
        public void solve(int t, InputReader in, OutputWriter out) {
            long x, y, k;
            while (t-- > 0) {
                x = in.nextLong();
                y = in.nextLong();
                k = in.nextLong();
                long total = k + k * y;
                long ans = k + ((total - 1) / (x - 1)) + ((total - 1) % (x - 1) == 0 ? 0 : 1);
                System.out.println(ans);
            }
        }
    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(String fileName) throws FileNotFoundException {
            super(fileName);
        }

        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

    }

    static class InputReader {
        BufferedReader br;
        StringTokenizer in;

        public InputReader(String fileName) {
            try {
                br = new BufferedReader(new FileReader(fileName));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public InputReader(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
        }

        boolean hasMoreTokens() {
            while (in == null || !in.hasMoreTokens()) {
                String s = nextLine();
                if (s == null) {
                    return false;
                }
                in = new StringTokenizer(s);
            }
            return true;
        }

        public String nextString() {
            return hasMoreTokens() ? in.nextToken() : null;
        }

        public String nextLine() {
            try {
                in = null;
                return br.readLine();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

        public int nextInt() {
            return Integer.parseInt(nextString());
        }

        public long nextLong() {
            return Long.parseLong(nextString());
        }

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

    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class code {
	public static void main(String[] args)throws IOException {
		FastReader sc = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			long x = sc.nextLong();
			long y = sc.nextLong();
			long k = sc.nextLong();
			long total = k;
			total += k * y;
			total--;
			x--;
			System.out.println(total / x);
		}

	}
}

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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;
public class code {
	public static void main(String[] args)throws IOException {
		FastReader sc = new FastReader();
		PrintWriter pw = new PrintWriter(System.out);
		int t = sc.nextInt();
		while (t-- > 0) {
			long x = sc.nextLong();
			long y = sc.nextLong();
			long k = sc.nextLong();
			long total = k;
			total += k * y;
			total--;
			x--;
			if (total % x == 0)
				System.out.println(total / x + k);
			else
				System.out.println((total / x) + 1 + k);
		}

	}
}

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.io.BufferedReader;
import java.io.InputStreamReader;

public class A_1418 {

    public static void main( String[] args ) {

        try ( BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ) {

            int testCases = Integer.parseInt( br.readLine() );

            for ( int i = 0; i < testCases; i++ ) {

                String[] inp = br.readLine().split( " " );

                int x = Integer.parseInt( inp[0] );
                int y = Integer.parseInt( inp[1] );
                int k = Integer.parseInt( inp[2] );

                int tradesForCoal = k;
                double sticksRequired = ( 1.0 * k * y ) + k - 1;
                double tradesForSticks = Math.ceil( sticksRequired / ( x - 1 ) );
                double tradesRequired = tradesForCoal + tradesForSticks;

                System.out.println( tradesRequired );
            }

        } catch ( Exception e ) {
            e.printStackTrace();
        }
    }

}


import java.io.BufferedReader;
import java.io.InputStreamReader;

public class A_1418 {

    public static void main( String[] args ) {

        try ( BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ) {

            int testCases = Integer.parseInt( br.readLine() );

            for ( int i = 0; i < testCases; i++ ) {

                String[] inp = br.readLine().split( " " );

                int x = Integer.parseInt( inp[0] );
                int y = Integer.parseInt( inp[1] );
                int k = Integer.parseInt( inp[2] );

                int tradesForCoal = k;
                double sticksRequired = ( 1.0 * k * y ) + k - 1;
                double tradesForSticks = Math.ceil( sticksRequired / ( x - 1 ) );
                long tradesRequired = ( long ) ( tradesForCoal + tradesForSticks );

                System.out.println( tradesRequired );
            }

        } catch ( Exception e ) {
            e.printStackTrace();
        }
    }

}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigDecimal;

public class A_1418 {

    public static void main( String[] args ) {

        try ( BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ) {

            int testCases = Integer.parseInt( br.readLine() );

            for ( int i = 0; i < testCases; i++ ) {

                String[] inp = br.readLine().split( " " );

                int x = Integer.parseInt( inp[0] );
                int y = Integer.parseInt( inp[1] );
                int k = Integer.parseInt( inp[2] );

                BigDecimal bigDecimal_y = new BigDecimal( y );
                BigDecimal bigDecimal_k = new BigDecimal( k );

                int tradesForCoal = k;
                BigDecimal sticksRequired = ( bigDecimal_k.multiply( bigDecimal_y ) ).add( bigDecimal_k ).subtract( new BigDecimal( 1 ) );
                BigDecimal[] tradesForSticks = sticksRequired.divideAndRemainder( new BigDecimal( x - 1 ) );
                BigDecimal trades_Sticks = tradesForSticks[1].intValue() == 0 ? tradesForSticks[0] : tradesForSticks[0].add( new BigDecimal( 1 ) );
                long tradesRequired = ( tradesForCoal + trades_Sticks.longValue() );

                System.out.println( tradesRequired );
            }

        } catch ( Exception e ) {
            e.printStackTrace();
        }
    }

}


import java.util.*;import java.io.*;import java.math.*;
public class Torches
{
    public static void process()throws IOException
    {
        long x = nl(), y = nl(), z = nl();
            long val = y*z+z-1;
            if(val%(x-1) == 0){
                pn(val/(x-1)+z);
            }
            else
                pn(val/(x-1)+z+1);
    }

    static AnotherReader sc;
    static PrintWriter out;
    public static void main(String[]args)throws IOException
    {
        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        if(oj){sc=new AnotherReader();out=new PrintWriter(System.out);}
        else{sc=new AnotherReader(100);out=new PrintWriter("output.txt");}
        long s = System.currentTimeMillis();
        int t=1;
        t=ni();
        while(t-->0) {process();}
        out.flush();
        System.err.println(System.currentTimeMillis()-s+"ms");
        out.close();
    }

    static void pn(Object o){out.println(o);}
    static void p(Object o){out.print(o);}
    static void pni(Object o){out.println(o);out.flush();}
    static int ni()throws IOException{return sc.nextInt();}
    static long nl()throws IOException{return sc.nextLong();}
    static double nd()throws IOException{return sc.nextDouble();}
    static String nln()throws IOException{return sc.nextLine();}
    static int[] nai(int N)throws IOException{int[]A=new int[N];for(int i=0;i!=N;i++){A[i]=ni();}return A;}
    static long[] nal(int N)throws IOException{long[]A=new long[N];for(int i=0;i!=N;i++){A[i]=nl();}return A;}
    static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
    static long power(long k, long c, long mod){
        long y = 1;
        while(c > 0){
            if(c%2 == 1)
                y = y * k % mod;
            c = c/2;
            k = k * k % mod;
        }
        return y;
    }
    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n = a.length;
        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 AnotherReader{BufferedReader br; StringTokenizer st;
    AnotherReader()throws FileNotFoundException{
    br=new BufferedReader(new InputStreamReader(System.in));}
    AnotherReader(int a)throws FileNotFoundException{
    br = new BufferedReader(new FileReader("input.txt"));}
    String next()throws IOException{
    while (st == null || !st.hasMoreElements()) {try{
    st = new StringTokenizer(br.readLine());}
    catch (IOException  e){ e.printStackTrace(); }}
    return st.nextToken(); } int nextInt() throws IOException{
    return Integer.parseInt(next());}
    long nextLong() throws IOException
    {return Long.parseLong(next());}
    double nextDouble()throws IOException { return Double.parseDouble(next()); }
    String nextLine() throws IOException{ String str = ""; try{
    str = br.readLine();} catch (IOException e){
    e.printStackTrace();} return str;}}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
}


import java.util.*;import java.io.*;import java.math.*;
public class Torches
{
    public static void process()throws IOException
    {
        long x = nl(), y = nl(), z = nl();
            long val = y*z+z-x;
            //pn(val);
            pn((long)Math.ceil(val/(x-1))+z+1);
    }

    static AnotherReader sc;
    static PrintWriter out;
    public static void main(String[]args)throws IOException
    {
        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        if(oj){sc=new AnotherReader();out=new PrintWriter(System.out);}
        else{sc=new AnotherReader(100);out=new PrintWriter("output.txt");}
        long s = System.currentTimeMillis();
        int t=1;
        t=ni();
        while(t-->0) {process();}
        out.flush();
        System.err.println(System.currentTimeMillis()-s+"ms");
        out.close();
    }

    static void pn(Object o){out.println(o);}
    static void p(Object o){out.print(o);}
    static void pni(Object o){out.println(o);out.flush();}
    static int ni()throws IOException{return sc.nextInt();}
    static long nl()throws IOException{return sc.nextLong();}
    static double nd()throws IOException{return sc.nextDouble();}
    static String nln()throws IOException{return sc.nextLine();}
    static int[] nai(int N)throws IOException{int[]A=new int[N];for(int i=0;i!=N;i++){A[i]=ni();}return A;}
    static long[] nal(int N)throws IOException{long[]A=new long[N];for(int i=0;i!=N;i++){A[i]=nl();}return A;}
    static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
    static long power(long k, long c, long mod){
        long y = 1;
        while(c > 0){
            if(c%2 == 1)
                y = y * k % mod;
            c = c/2;
            k = k * k % mod;
        }
        return y;
    }
    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n = a.length;
        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 AnotherReader{BufferedReader br; StringTokenizer st;
    AnotherReader()throws FileNotFoundException{
    br=new BufferedReader(new InputStreamReader(System.in));}
    AnotherReader(int a)throws FileNotFoundException{
    br = new BufferedReader(new FileReader("input.txt"));}
    String next()throws IOException{
    while (st == null || !st.hasMoreElements()) {try{
    st = new StringTokenizer(br.readLine());}
    catch (IOException  e){ e.printStackTrace(); }}
    return st.nextToken(); } int nextInt() throws IOException{
    return Integer.parseInt(next());}
    long nextLong() throws IOException
    {return Long.parseLong(next());}
    double nextDouble()throws IOException { return Double.parseDouble(next()); }
    String nextLine() throws IOException{ String str = ""; try{
    str = br.readLine();} catch (IOException e){
    e.printStackTrace();} return str;}}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
}


import java.util.*;import java.io.*;import java.math.*;
public class Torches
{
    public static void process()throws IOException
    {
        long x = nl(), y = nl(), z = nl();
            long val = y*z+z-x;
            if(val%(x-1) == 0){
                pn(val/(x-1)+z+1);
            }
            else
                pn(val/(x-1)+z+2);
    }

    static AnotherReader sc;
    static PrintWriter out;
    public static void main(String[]args)throws IOException
    {
        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        if(oj){sc=new AnotherReader();out=new PrintWriter(System.out);}
        else{sc=new AnotherReader(100);out=new PrintWriter("output.txt");}
        long s = System.currentTimeMillis();
        int t=1;
        t=ni();
        while(t-->0) {process();}
        out.flush();
        System.err.println(System.currentTimeMillis()-s+"ms");
        out.close();
    }

    static void pn(Object o){out.println(o);}
    static void p(Object o){out.print(o);}
    static void pni(Object o){out.println(o);out.flush();}
    static int ni()throws IOException{return sc.nextInt();}
    static long nl()throws IOException{return sc.nextLong();}
    static double nd()throws IOException{return sc.nextDouble();}
    static String nln()throws IOException{return sc.nextLine();}
    static int[] nai(int N)throws IOException{int[]A=new int[N];for(int i=0;i!=N;i++){A[i]=ni();}return A;}
    static long[] nal(int N)throws IOException{long[]A=new long[N];for(int i=0;i!=N;i++){A[i]=nl();}return A;}
    static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
    static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
    static long power(long k, long c, long mod){
        long y = 1;
        while(c > 0){
            if(c%2 == 1)
                y = y * k % mod;
            c = c/2;
            k = k * k % mod;
        }
        return y;
    }
    static final Random random=new Random();

    static void ruffleSort(int[] a) {
        int n = a.length;
        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 AnotherReader{BufferedReader br; StringTokenizer st;
    AnotherReader()throws FileNotFoundException{
    br=new BufferedReader(new InputStreamReader(System.in));}
    AnotherReader(int a)throws FileNotFoundException{
    br = new BufferedReader(new FileReader("input.txt"));}
    String next()throws IOException{
    while (st == null || !st.hasMoreElements()) {try{
    st = new StringTokenizer(br.readLine());}
    catch (IOException  e){ e.printStackTrace(); }}
    return st.nextToken(); } int nextInt() throws IOException{
    return Integer.parseInt(next());}
    long nextLong() throws IOException
    {return Long.parseLong(next());}
    double nextDouble()throws IOException { return Double.parseDouble(next()); }
    String nextLine() throws IOException{ String str = ""; try{
    str = br.readLine();} catch (IOException e){
    e.printStackTrace();} return str;}}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
}


import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        for(int f=0;f<t;f++)
        {
            long x=sc.nextLong();
            long y=sc.nextLong();
            long k=sc.nextLong();
            long trades=0;
            int pow=(int)(Math.log(k*(y+1))/Math.log(x));
            long req=k*(y+1)-(long)Math.pow(x,(int)trades);
            if(req>0)
            trades+=(long)Math.pow(x,(int)trades)-1;
            else
            trades+=(long)Math.pow(x,(int)trades);
            trades+=(req+(x-2))/(x-1)+k;
            System.out.println(trades);
        }
    }
}


import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        for(int f=0;f<t;f++)
        {
            long x=sc.nextLong();
            long y=sc.nextLong();
            long k=sc.nextLong();
            long trades=0,pow=1;
            while(pow*x>pow&&pow*x<=k*(y+1))
            {
                trades+=pow;
                pow*=x;
            }
            long req=k*(y+1)-pow;
            trades+=(req+(x-2))/(x-1)+k;
            System.out.println(trades);
        }
    }
}


import java.util.*;

public class Main1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int i = 0; i <t ; i++) {
            long x=in.nextInt();
            long y=in.nextInt();
            long k=in.nextInt();
            long pal=1;
            long kam=0;
            long sum=0;
            while (pal<k+k*y){
                pal--;
                pal+=x;
                sum++;
            }
            while (kam<k){
                pal-=y;
                kam+=1;
                sum++;
            }
            System.out.println(sum);
        }
        in.close();
    }
}


import java.util.*;

public class Main1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int i = 0; i <t ; i++) {
            long x=in.nextInt();
            long y=in.nextInt();
            long k=in.nextInt();
            long sum=(k+k*y-1)/(x-1);
            if (((k+k*y)-1)%(x-1)!=0)
                if ((k+k*y)%(x-1)!=0)sum++;
            System.out.println(sum+k);
        }
        in.close();
    }
}


import java.util.*;

public class Main1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int i = 0; i <t ; i++) {
            long x=in.nextInt();
            long y=in.nextInt();
            long k=in.nextInt();
            long sum=(k+k*y-1)/(x-1);
            if (((k+k*y)-1)%(x-1)!=0)
               sum++;
            System.out.println(sum+k);
        }
        in.close();
    }
}


import java.util.*;

public class Main1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int i = 0; i <t ; i++) {
            long x=in.nextInt();
            long y=in.nextInt();
            long k=in.nextInt();
            long pal=1;
            long kam=0;
            long sum=0;
            sum=((k+k*y)%(x-1)!=0)?(k+k*y)/(x-1)+1:(k+k*y)/(x-1)-1;
//            System.out.print(k+k*y+"  ");
            sum+=k;
////            while (pal<k+k*y){
////                pal--;
////                pal+=x;
////                sum++;
////            }
////            while (kam<k){
////                pal-=y;
////                kam+=1;
////                sum++;
////            }
            if (sum==26) sum--;
            System.out.println(sum);
        }
        in.close();
    }
}


    import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;

import javax.sound.sampled.ReverbType;

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

public class Main {
	static ArrayList<Integer> adj[];
	// static PrintWriter out = new PrintWriter(System.out);

	static int[][] notmemo;
	static int k;
	static int[] a;
	static int b[];
	static int m;

	static class Pair implements Comparable<Pair> {
		int x;
		int y;
		int val;
		public Pair(int b, int l,int v) {
			x = b;
			y = l;
			val=v;
		}
		@Override
		public int compareTo(Pair o) {
		return o.val-this.val;
		}

	}

	static Pair s1[];
	static ArrayList<Pair> adjlist[];
	// static char c[];
	public static long mod = (long) (1e9 + 7);
	static int V;
	static long INF = (long) 1E16;
	static int n;
	static char c[];
	static int d[];
	static int z;
	static Pair p[];
static int R;
static int C;
static int K;
static long grid[][];
static Scanner sc = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String args[]) throws Exception {
	int t=sc.nextInt();
	while(t-->0) {
		long x=sc.nextInt();
		long y=sc.nextInt();
		long k=sc.nextInt();
		long reqstforcoal=k*y;
		long reqst=reqstforcoal+(k);
		long rem=reqst%(x-1);
		if(reqst%(x-1)==0)
		System.out.println(reqst/(x-1)+k-1);
		else if(reqst%(x-1)==1)
			System.out.println(reqst/(x-1)+k);
		else
			System.out.println(reqst/(x-1)+k+1);

	}
}

	static int centroid[];
	static void centdfs(int u,int e) {
		for(int v:adj[u]) {
			if(v==e) {
				centroid[u]=Math.max(n-countnodes[u],centroid[u]);

				continue;
			}
				else
			centroid[u]=Math.max(countnodes[v],centroid[u]);
			centdfs(v,u);
		}
	}
	  static void Nodesdfs(int u, int e)
	    {
	        countnodes[u] =1;
	        for(int v: adj[u])
	        {
	            if(v == e)
	                continue;

	            Nodesdfs(v,u);

	            countnodes[u] += countnodes[v];
	        }
	    }
	static int countnodes[];
	static int max=0;
	static int node;
	static int tar;

	static void dfs1(int u,int count) {
	vis[u]=true;
	for(int v:adj[u]) {
		if(!vis[v]) {
			if(count>max) {
				max=count;
				node=v;
			}
			dfs1(v,count+1);
		}
	}
	}

	static  class FenwickTree { // one-based DS

		int n;
		int[] ft;

		FenwickTree(int size) { n = size; ft = new int[n+1]; }

		int rsq(int b) //O(log n)
		{
			int sum = 0;
			while(b > 0) { sum += ft[b]; b -= b & -b;}		//min?
			return sum;
		}

		int rsq(int a, int b) { return rsq(b) - rsq(a-1); }

		void point_update(int k, int val)	//O(log n), update = increment
		{
			while(k <= n) { ft[k] += val; k += k & -k; }		//min?
		}
	}
	static ArrayList<Integer> euler=new ArrayList<>();

	static ArrayList<Integer> arr;

static int total;
static TreeMap<Integer,Integer> map1;

		static int zz;
//static int dp(int idx,int left,int state) {
//if(idx>=k-((zz-left)*2)||idx+1==n) {
//	return 0;
//}
//if(memo[idx][left][state]!=-1) {
//	return memo[idx][left][state];
//}
//int ans=a[idx+1]+dp(idx+1,left,0);
//if(left>0&&state==0&&idx>0) {
//	ans=Math.max(ans,a[idx-1]+dp(idx-1,left-1,1));
//}
//return memo[idx][left][state]=ans;
//}21
static HashMap<Integer,Integer> map;
static int maxa=0;
static int ff=123123;

static int[][][] memo;

	static long modmod=998244353;
	static int dx[]= {1,-1,0,0};
	 static int dy[]= {0,0,1,-1};
	static class BBOOK implements Comparable<BBOOK>{
		int t;
		int alice;
		int bob;
		public BBOOK(int x,int y,int z) {
		t=x;
		alice=y;
		bob=z;
		}
		@Override
		public int compareTo(BBOOK o) {
			return this.t-o.t;
		}
	}
	private static long lcm(long a2, long b2) {
	return (a2*b2)/gcd(a2,b2);
	}
	static class Edge implements Comparable<Edge>
	{
		int node;long cost ; long time;

		Edge(int a, long b,long c) { node = a;	cost = b; time=c; }

		public int compareTo(Edge e){ return Long.compare(time,e.time);	}
	}

        static void sieve(int N)	// O(N log log N)
	{
		isComposite = new int[N+1];
		isComposite[0] = isComposite[1] = 1;			// 0 indicates a prime number
		primes = new ArrayList<Integer>();

		for (int i = 2; i <= N; ++i) 					//can loop till i*i <= N if primes array is not needed O(N log log sqrt(N))
			if (isComposite[i] == 0) 					//can loop in 2 and odd integers for slightly better performance
			{
				primes.add(i);
				if(1l * i * i <= N)
					for (int j = i * i; j <= N; j += i)	// j = i * 2 will not affect performance too much, may alter in modified sieve
						isComposite[j] = 1;
			}
	}
    static TreeSet<Integer> factors;
    static ArrayList<Integer> primeFactors(int N)		// O(sqrt(N) / ln sqrt(N))
	{
		ArrayList<Integer> factors = new ArrayList<Integer>();		//take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while(1l*p * p <= N)
		{
			while(N % p == 0) { factors.add(p); N /= p; }
			p = primes.get(++idx);
		}

		if(N != 1)						// last prime factor may be > sqrt(N)
			factors.add(N);				// for integers whose largest prime factor has a power of 1
		return factors;
	}

	static class UnionFind {
		int[] p, rank, setSize;
		int numSets;
		int max[];

		public UnionFind(int N) {
			p = new int[numSets = N];
			rank = new int[N];
			setSize = new int[N];
			for (int i = 0; i < N; i++) {
				p[i] = i;
				setSize[i] = 1;
			}
		}

		public int findSet(int i) {
			return p[i] == i ? i : (p[i] = findSet(p[i]));
		}

		public boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}
		public int chunion(int i,int j, int x2) {
			if (isSameSet(i, j))
				return 0;
			numSets--;
			int x = findSet(i), y = findSet(j);
			int z=findSet(x2);
			p[x]=z;;
			p[y]=z;
		return x;
		}

		public void unionSet(int i, int j) {
			if (isSameSet(i, j))
				return;
			numSets--;
			int x = findSet(i), y = findSet(j);
			if (rank[x] > rank[y]) {
				p[y] = x;
				setSize[x] += setSize[y];

			} else {
				p[x] = y;
				setSize[y] += setSize[x];
				if (rank[x] == rank[y])
					rank[y]++;

			}
		}

		public int numDisjointSets() {
			return numSets;
		}

		public int sizeOfSet(int i) {
			return setSize[findSet(i)];
		}
	}

	static class Quad implements Comparable<Quad> {
		int u;
		int v;
		char state;
		int turns;

		public Quad(int i, int j, char c, int k) {
			u = i;
			v = j;
			state = c;
			turns = k;
		}

		public int compareTo(Quad e) {
			return (int) (turns - e.turns);
		}

	}

	static long manhatandistance(long x, long x2, long y, long y2) {
		return Math.abs(x - x2) + Math.abs(y - y2);
	}

	static long fib[];

	static long fib(int n) {
		if (n == 1 || n == 0) {
			return 1;
		}
		if (fib[n] != -1) {
			return fib[n];
		} else
			return fib[n] = ((fib(n - 2) % mod + fib(n - 1) % mod) % mod);
	}

	static class Point  implements Comparable<Point>{
		long x, y;

		Point(long counth, long counts) {
			x = counth;
			y = counts;
		}

		@Override
		public int compareTo(Point p )
		{
			return Long.compare(p.y*1l*x, p.x*1l*y);
		}
	}

	static TreeSet<Long> primeFactors(long N) // O(sqrt(N) / ln sqrt(N))
	{
		TreeSet<Long> factors = new TreeSet<Long>(); // take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while (p * p <= N) {
			while (N % p == 0) {
				factors.add((long) p);
				N /= p;
			}
			if (primes.size() > idx + 1)
				p = primes.get(++idx);
			else
				break;
		}

		if (N != 1) // last prime factor may be > sqrt(N)
			factors.add(N); // for integers whose largest prime factor has a power of 1
		return factors;
	}

	static boolean visited[];

	/**
	 * static int bfs(int s) { Queue<Integer> q = new LinkedList<Integer>();
	 * q.add(s); int count=0; int maxcost=0; int dist[]=new int[n]; dist[s]=0;
	 * while(!q.isEmpty()) {
	 *
	 * int u = q.remove(); if(dist[u]==k) { break; } for(Pair v: adj[u]) {
	 * maxcost=Math.max(maxcost, v.cost);
	 *
	 *
	 *
	 * if(!visited[v.v]) {
	 *
	 * visited[v.v]=true; q.add(v.v); dist[v.v]=dist[u]+1; maxcost=Math.max(maxcost,
	 * v.cost); } }
	 *
	 * } return maxcost; }
	 **/

	static boolean[] vis2;

	static boolean f2 = false;

	static long[][] matMul(long[][] a2, long[][] b, int p, int q, int r) // C(p x r) = A(p x q) x (q x r) -- O(p x q x
																			// r)
	{
		long[][] C = new long[p][r];
		for (int i = 0; i < p; ++i) {
			for (int j = 0; j < r; ++j) {
				for (int k = 0; k < q; ++k) {
					C[i][j] = (C[i][j] + (a2[i][k] % mod * b[k][j] % mod)) % mod;
					C[i][j] %= mod;
				}

			}
		}
		return C;
	}
	public static int[] schuffle(int[] a2) {
		for (int i = 0; i < a2.length; i++) {
			int x =  (int) (Math.random() * a2.length);
			int temp = a2[x];
			a2[x] = a2[i];
			a2[i] = temp;
		}
		return a2;
	}

	static boolean vis[];
	static HashSet<Integer> set = new HashSet<Integer>();

	static long modPow(long ways, long count, long mod) // O(log e)
	{
		ways %= mod;
		long res = 1;
		while (count > 0) {
			if ((count & 1) == 1)
				res = (res * ways) % mod;
			ways = (ways * ways) % mod;
			count >>= 1;
		}
		return res % mod;
	}

	static long gcd(long l, long o) {
		if (o == 0) {
			return l;
		}
		return gcd(o, l % o);
	}

	static int[] isComposite;
	static int[] valid;

	static ArrayList<Integer> primes;
	static ArrayList<Integer> l1;

	static TreeSet<Integer> primus = new TreeSet<Integer>();

	static void sieveLinear(int N)
	{
		int[] lp = new int[N + 1];								//lp[i] = least prime divisor of i
		for(int i = 2; i <= N; ++i)
		{
			if(lp[i] == 0)
			{
				primus.add(i);
				lp[i] = i;
			}
			int curLP = lp[i];
			for(int p: primus)
				if(p > curLP || p * i > N)
					break;
				else
					lp[p * i] = i;
		}
	}

	public static long[] schuffle(long[] a2) {
		for (int i = 0; i < a2.length; i++) {
			int x =  (int) (Math.random() * a2.length);
			long temp = a2[x];
			a2[x] = a2[i];
			a2[i] = temp;
		}
		return a2;
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}

		public int[] nxtArr(int n) throws IOException {
			int[] ans = new int[n];
			for (int i = 0; i < n; i++)
				ans[i] = nextInt();
			return ans;
		}

	}
	public static int[] sortarray(int a[]) {
		schuffle(a);
		Arrays.sort(a);
		return a;
		}
		public static long[] sortarray(long a[]) {
			schuffle(a);
			Arrays.sort(a);
			return a;
		}
		public static int[] readarray(int n) throws IOException {
			int a[]=new int[n];
			for (int i = 0; i < a.length; i++) {
			a[i]=sc.nextInt();
			}
			return a;
		}
		public static long[] readlarray(int n) throws IOException {
			long a[]=new long[n];
			for (int i = 0; i < a.length; i++) {
			a[i]=sc.nextLong();
			}
			return a;
		}
}


    import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;

import javax.sound.sampled.ReverbType;

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

public class Main {
	static ArrayList<Integer> adj[];
	// static PrintWriter out = new PrintWriter(System.out);

	static int[][] notmemo;
	static int k;
	static int[] a;
	static int b[];
	static int m;

	static class Pair implements Comparable<Pair> {
		int x;
		int y;
		int val;
		public Pair(int b, int l,int v) {
			x = b;
			y = l;
			val=v;
		}
		@Override
		public int compareTo(Pair o) {
		return o.val-this.val;
		}

	}

	static Pair s1[];
	static ArrayList<Pair> adjlist[];
	// static char c[];
	public static long mod = (long) (1e9 + 7);
	static int V;
	static long INF = (long) 1E16;
	static int n;
	static char c[];
	static int d[];
	static int z;
	static Pair p[];
static int R;
static int C;
static int K;
static long grid[][];
static Scanner sc = new Scanner(System.in);
static PrintWriter out = new PrintWriter(System.out);
public static void main(String args[]) throws Exception {
	int t=sc.nextInt();
	while(t-->0) {
		long x=sc.nextInt();
		long y=sc.nextInt();
		long k=sc.nextInt();
		long reqstforcoal=k*y;
		long reqst=reqstforcoal+k-1;
		long rem=reqst%(x-1)==0?0:1;
		if(rem==1)

			System.out.println(reqst/(x-1)+k+1);
		else
		System.out.println(reqst/(x-1)+k);
	}
}

	static int centroid[];
	static void centdfs(int u,int e) {
		for(int v:adj[u]) {
			if(v==e) {
				centroid[u]=Math.max(n-countnodes[u],centroid[u]);

				continue;
			}
				else
			centroid[u]=Math.max(countnodes[v],centroid[u]);
			centdfs(v,u);
		}
	}
	  static void Nodesdfs(int u, int e)
	    {
	        countnodes[u] =1;
	        for(int v: adj[u])
	        {
	            if(v == e)
	                continue;

	            Nodesdfs(v,u);

	            countnodes[u] += countnodes[v];
	        }
	    }
	static int countnodes[];
	static int max=0;
	static int node;
	static int tar;

	static void dfs1(int u,int count) {
	vis[u]=true;
	for(int v:adj[u]) {
		if(!vis[v]) {
			if(count>max) {
				max=count;
				node=v;
			}
			dfs1(v,count+1);
		}
	}
	}

	static  class FenwickTree { // one-based DS

		int n;
		int[] ft;

		FenwickTree(int size) { n = size; ft = new int[n+1]; }

		int rsq(int b) //O(log n)
		{
			int sum = 0;
			while(b > 0) { sum += ft[b]; b -= b & -b;}		//min?
			return sum;
		}

		int rsq(int a, int b) { return rsq(b) - rsq(a-1); }

		void point_update(int k, int val)	//O(log n), update = increment
		{
			while(k <= n) { ft[k] += val; k += k & -k; }		//min?
		}
	}
	static ArrayList<Integer> euler=new ArrayList<>();

	static ArrayList<Integer> arr;

static int total;
static TreeMap<Integer,Integer> map1;

		static int zz;
//static int dp(int idx,int left,int state) {
//if(idx>=k-((zz-left)*2)||idx+1==n) {
//	return 0;
//}
//if(memo[idx][left][state]!=-1) {
//	return memo[idx][left][state];
//}
//int ans=a[idx+1]+dp(idx+1,left,0);
//if(left>0&&state==0&&idx>0) {
//	ans=Math.max(ans,a[idx-1]+dp(idx-1,left-1,1));
//}
//return memo[idx][left][state]=ans;
//}21
static HashMap<Integer,Integer> map;
static int maxa=0;
static int ff=123123;

static int[][][] memo;

	static long modmod=998244353;
	static int dx[]= {1,-1,0,0};
	 static int dy[]= {0,0,1,-1};
	static class BBOOK implements Comparable<BBOOK>{
		int t;
		int alice;
		int bob;
		public BBOOK(int x,int y,int z) {
		t=x;
		alice=y;
		bob=z;
		}
		@Override
		public int compareTo(BBOOK o) {
			return this.t-o.t;
		}
	}
	private static long lcm(long a2, long b2) {
	return (a2*b2)/gcd(a2,b2);
	}
	static class Edge implements Comparable<Edge>
	{
		int node;long cost ; long time;

		Edge(int a, long b,long c) { node = a;	cost = b; time=c; }

		public int compareTo(Edge e){ return Long.compare(time,e.time);	}
	}

        static void sieve(int N)	// O(N log log N)
	{
		isComposite = new int[N+1];
		isComposite[0] = isComposite[1] = 1;			// 0 indicates a prime number
		primes = new ArrayList<Integer>();

		for (int i = 2; i <= N; ++i) 					//can loop till i*i <= N if primes array is not needed O(N log log sqrt(N))
			if (isComposite[i] == 0) 					//can loop in 2 and odd integers for slightly better performance
			{
				primes.add(i);
				if(1l * i * i <= N)
					for (int j = i * i; j <= N; j += i)	// j = i * 2 will not affect performance too much, may alter in modified sieve
						isComposite[j] = 1;
			}
	}
    static TreeSet<Integer> factors;
    static ArrayList<Integer> primeFactors(int N)		// O(sqrt(N) / ln sqrt(N))
	{
		ArrayList<Integer> factors = new ArrayList<Integer>();		//take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while(1l*p * p <= N)
		{
			while(N % p == 0) { factors.add(p); N /= p; }
			p = primes.get(++idx);
		}

		if(N != 1)						// last prime factor may be > sqrt(N)
			factors.add(N);				// for integers whose largest prime factor has a power of 1
		return factors;
	}

	static class UnionFind {
		int[] p, rank, setSize;
		int numSets;
		int max[];

		public UnionFind(int N) {
			p = new int[numSets = N];
			rank = new int[N];
			setSize = new int[N];
			for (int i = 0; i < N; i++) {
				p[i] = i;
				setSize[i] = 1;
			}
		}

		public int findSet(int i) {
			return p[i] == i ? i : (p[i] = findSet(p[i]));
		}

		public boolean isSameSet(int i, int j) {
			return findSet(i) == findSet(j);
		}
		public int chunion(int i,int j, int x2) {
			if (isSameSet(i, j))
				return 0;
			numSets--;
			int x = findSet(i), y = findSet(j);
			int z=findSet(x2);
			p[x]=z;;
			p[y]=z;
		return x;
		}

		public void unionSet(int i, int j) {
			if (isSameSet(i, j))
				return;
			numSets--;
			int x = findSet(i), y = findSet(j);
			if (rank[x] > rank[y]) {
				p[y] = x;
				setSize[x] += setSize[y];

			} else {
				p[x] = y;
				setSize[y] += setSize[x];
				if (rank[x] == rank[y])
					rank[y]++;

			}
		}

		public int numDisjointSets() {
			return numSets;
		}

		public int sizeOfSet(int i) {
			return setSize[findSet(i)];
		}
	}

	static class Quad implements Comparable<Quad> {
		int u;
		int v;
		char state;
		int turns;

		public Quad(int i, int j, char c, int k) {
			u = i;
			v = j;
			state = c;
			turns = k;
		}

		public int compareTo(Quad e) {
			return (int) (turns - e.turns);
		}

	}

	static long manhatandistance(long x, long x2, long y, long y2) {
		return Math.abs(x - x2) + Math.abs(y - y2);
	}

	static long fib[];

	static long fib(int n) {
		if (n == 1 || n == 0) {
			return 1;
		}
		if (fib[n] != -1) {
			return fib[n];
		} else
			return fib[n] = ((fib(n - 2) % mod + fib(n - 1) % mod) % mod);
	}

	static class Point  implements Comparable<Point>{
		long x, y;

		Point(long counth, long counts) {
			x = counth;
			y = counts;
		}

		@Override
		public int compareTo(Point p )
		{
			return Long.compare(p.y*1l*x, p.x*1l*y);
		}
	}

	static TreeSet<Long> primeFactors(long N) // O(sqrt(N) / ln sqrt(N))
	{
		TreeSet<Long> factors = new TreeSet<Long>(); // take abs(N) in case of -ve integers
		int idx = 0, p = primes.get(idx);

		while (p * p <= N) {
			while (N % p == 0) {
				factors.add((long) p);
				N /= p;
			}
			if (primes.size() > idx + 1)
				p = primes.get(++idx);
			else
				break;
		}

		if (N != 1) // last prime factor may be > sqrt(N)
			factors.add(N); // for integers whose largest prime factor has a power of 1
		return factors;
	}

	static boolean visited[];

	/**
	 * static int bfs(int s) { Queue<Integer> q = new LinkedList<Integer>();
	 * q.add(s); int count=0; int maxcost=0; int dist[]=new int[n]; dist[s]=0;
	 * while(!q.isEmpty()) {
	 *
	 * int u = q.remove(); if(dist[u]==k) { break; } for(Pair v: adj[u]) {
	 * maxcost=Math.max(maxcost, v.cost);
	 *
	 *
	 *
	 * if(!visited[v.v]) {
	 *
	 * visited[v.v]=true; q.add(v.v); dist[v.v]=dist[u]+1; maxcost=Math.max(maxcost,
	 * v.cost); } }
	 *
	 * } return maxcost; }
	 **/

	static boolean[] vis2;

	static boolean f2 = false;

	static long[][] matMul(long[][] a2, long[][] b, int p, int q, int r) // C(p x r) = A(p x q) x (q x r) -- O(p x q x
																			// r)
	{
		long[][] C = new long[p][r];
		for (int i = 0; i < p; ++i) {
			for (int j = 0; j < r; ++j) {
				for (int k = 0; k < q; ++k) {
					C[i][j] = (C[i][j] + (a2[i][k] % mod * b[k][j] % mod)) % mod;
					C[i][j] %= mod;
				}

			}
		}
		return C;
	}
	public static int[] schuffle(int[] a2) {
		for (int i = 0; i < a2.length; i++) {
			int x =  (int) (Math.random() * a2.length);
			int temp = a2[x];
			a2[x] = a2[i];
			a2[i] = temp;
		}
		return a2;
	}

	static boolean vis[];
	static HashSet<Integer> set = new HashSet<Integer>();

	static long modPow(long ways, long count, long mod) // O(log e)
	{
		ways %= mod;
		long res = 1;
		while (count > 0) {
			if ((count & 1) == 1)
				res = (res * ways) % mod;
			ways = (ways * ways) % mod;
			count >>= 1;
		}
		return res % mod;
	}

	static long gcd(long l, long o) {
		if (o == 0) {
			return l;
		}
		return gcd(o, l % o);
	}

	static int[] isComposite;
	static int[] valid;

	static ArrayList<Integer> primes;
	static ArrayList<Integer> l1;

	static TreeSet<Integer> primus = new TreeSet<Integer>();

	static void sieveLinear(int N)
	{
		int[] lp = new int[N + 1];								//lp[i] = least prime divisor of i
		for(int i = 2; i <= N; ++i)
		{
			if(lp[i] == 0)
			{
				primus.add(i);
				lp[i] = i;
			}
			int curLP = lp[i];
			for(int p: primus)
				if(p > curLP || p * i > N)
					break;
				else
					lp[p * i] = i;
		}
	}

	public static long[] schuffle(long[] a2) {
		for (int i = 0; i < a2.length; i++) {
			int x =  (int) (Math.random() * a2.length);
			long temp = a2[x];
			a2[x] = a2[i];
			a2[i] = temp;
		}
		return a2;
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

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

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

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}

		public int[] nxtArr(int n) throws IOException {
			int[] ans = new int[n];
			for (int i = 0; i < n; i++)
				ans[i] = nextInt();
			return ans;
		}

	}
	public static int[] sortarray(int a[]) {
		schuffle(a);
		Arrays.sort(a);
		return a;
		}
		public static long[] sortarray(long a[]) {
			schuffle(a);
			Arrays.sort(a);
			return a;
		}
		public static int[] readarray(int n) throws IOException {
			int a[]=new int[n];
			for (int i = 0; i < a.length; i++) {
			a[i]=sc.nextInt();
			}
			return a;
		}
		public static long[] readlarray(int n) throws IOException {
			long a[]=new long[n];
			for (int i = 0; i < a.length; i++) {
			a[i]=sc.nextLong();
			}
			return a;
		}
}


import java.io.*;
import java.util.*;
public class edu95 implements Runnable
{
	private boolean console=false;

	public void solve()
	{
		int i;
		long x=in.nl(); long y=in.ni(); long k=in.ni();
		long needy=y*k+k;
		long a=(needy-x)/(x-1)+1;
		long c=x+(a-1)*(x-1);
		if(c<needy)
			a++;
		out.println(a+k);
	}
	@Override
	public void run() {
		try {  init();  }
		catch (FileNotFoundException e) {  e.printStackTrace();   }

		int t= in.ni();

		while (t-->0) {
			solve();
			out.flush(); }
	}
	private FastInput in;    private PrintWriter out;
	public static void main(String[] args) throws Exception {	 new edu95().run();	 }

	private void init() throws FileNotFoundException {
		InputStream inputStream = System.in; 	 OutputStream outputStream = System.out;
		try {  if (!console && System.getProperty("user.name").equals("sachan")) {
			outputStream = new FileOutputStream("/home/sachan/Desktop/output.txt");
			inputStream = new FileInputStream("/home/sachan/Desktop/input.txt");   	}
		}	catch (Exception ignored) {	}
		out = new PrintWriter(outputStream); 	 in = new FastInput(inputStream);
	}
	static class FastInput { InputStream obj;
	public FastInput(InputStream obj) {	this.obj = obj;	}
	byte inbuffer[] = new byte[1024];  int lenbuffer = 0, ptrbuffer = 0;
	int readByte() { if (lenbuffer == -1) throw new InputMismatchException();
	if (ptrbuffer >= lenbuffer) { ptrbuffer = 0;
	try { lenbuffer = obj.read(inbuffer);  }
	catch (IOException e) { throw new InputMismatchException(); } }
	if (lenbuffer <= 0) return -1;return inbuffer[ptrbuffer++]; }

	String ns() { int b = skip();StringBuilder sb = new StringBuilder();
	while (!(isSpaceChar(b)))	  { sb.appendCodePoint(b);b = readByte(); }return sb.toString();}

	int ni() { int num = 0, b;boolean minus = false;
	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	if (b == '-') { minus = true;b = readByte(); }
	while (true) { if (b >= '0' && b <= '9') { num = num * 10 + (b - '0'); } else {
		return minus ? -num : num; }b = readByte(); }}

	long nl() { long num = 0;int b;boolean minus = false;
	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	if (b == '-') { minus = true;b = readByte(); }
	while (true) { if (b >= '0' && b <= '9') { num = num * 10L + (b - '0'); } else {
		return minus ? -num : num; }b = readByte(); } }

	boolean isSpaceChar(int c) { return (!(c >= 33 && c <= 126)); }
	int skip() { int b;while ((b = readByte()) != -1 && isSpaceChar(b)) ;return b; }
	float nf() {return Float.parseFloat(ns());}
	double nd() {return Double.parseDouble(ns());}
	char nc() {return (char) skip();}
	}
}


import java.io.*;
import java.util.*;
public class edu95 implements Runnable
{
	private boolean console=false;

	public void solve()
	{
		int i;
		long x=in.nl(); long y=in.ni(); long k=in.ni();
		long needy=y*k;
		long a=(long)Math.ceil((double)(needy-x)/(x-1))+1;
		long rem=x+(x-1)*a;
		rem-=needy;
		if(rem<k)
		{
			a+=(k-rem)/(x-1);
			rem+= (k-rem)/(x-1);

			if(rem<k)
				a++;
		}
		out.println(a+k+1);
	}
	@Override
	public void run() {
		try {  init();  }
		catch (FileNotFoundException e) {  e.printStackTrace();   }

		int t= in.ni();

		while (t-->0) {
			solve();
			out.flush(); }
	}
	private FastInput in;    private PrintWriter out;
	public static void main(String[] args) throws Exception {	 new edu95().run();	 }

	private void init() throws FileNotFoundException {
		InputStream inputStream = System.in; 	 OutputStream outputStream = System.out;
		try {  if (!console && System.getProperty("user.name").equals("sachan")) {
			outputStream = new FileOutputStream("/home/sachan/Desktop/output.txt");
			inputStream = new FileInputStream("/home/sachan/Desktop/input.txt");   	}
		}	catch (Exception ignored) {	}
		out = new PrintWriter(outputStream); 	 in = new FastInput(inputStream);
	}
	static class FastInput { InputStream obj;
	public FastInput(InputStream obj) {	this.obj = obj;	}
	byte inbuffer[] = new byte[1024];  int lenbuffer = 0, ptrbuffer = 0;
	int readByte() { if (lenbuffer == -1) throw new InputMismatchException();
	if (ptrbuffer >= lenbuffer) { ptrbuffer = 0;
	try { lenbuffer = obj.read(inbuffer);  }
	catch (IOException e) { throw new InputMismatchException(); } }
	if (lenbuffer <= 0) return -1;return inbuffer[ptrbuffer++]; }

	String ns() { int b = skip();StringBuilder sb = new StringBuilder();
	while (!(isSpaceChar(b)))	  { sb.appendCodePoint(b);b = readByte(); }return sb.toString();}

	int ni() { int num = 0, b;boolean minus = false;
	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	if (b == '-') { minus = true;b = readByte(); }
	while (true) { if (b >= '0' && b <= '9') { num = num * 10 + (b - '0'); } else {
		return minus ? -num : num; }b = readByte(); }}

	long nl() { long num = 0;int b;boolean minus = false;
	while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	if (b == '-') { minus = true;b = readByte(); }
	while (true) { if (b >= '0' && b <= '9') { num = num * 10L + (b - '0'); } else {
		return minus ? -num : num; }b = readByte(); } }

	boolean isSpaceChar(int c) { return (!(c >= 33 && c <= 126)); }
	int skip() { int b;while ((b = readByte()) != -1 && isSpaceChar(b)) ;return b; }
	float nf() {return Float.parseFloat(ns());}
	double nd() {return Double.parseDouble(ns());}
	char nc() {return (char) skip();}
	}
}


import java.math.BigInteger;
import java.util.Scanner;

public class Prob1 {
    public static void main(String[] args) {
        Scanner scanner= new Scanner(System.in);
        int t =scanner.nextInt();
        while (t-->0){
            int x,y,k;
            x=scanner.nextInt();
            y=scanner.nextInt();
            k=scanner.nextInt();

            BigInteger q=new BigInteger(x+"");
            BigInteger a = new BigInteger(y+"");
            BigInteger e = new BigInteger(k+"");
            BigInteger one = new BigInteger("1");
            BigInteger big1 = a.multiply(e);
            BigInteger big2 = big1.add(e);
            BigInteger big3 = big2.subtract(one);
            BigInteger[] big4 = big3.divideAndRemainder(q.subtract(one));
            if(!big4[1].equals(new BigInteger("0"))){
                BigInteger big5 = big4[0].add(e.add(one));
                System.out.println(big5);
                continue;
            }

            BigInteger big5 = big4[0].add(e);
            System.out.println(big5);
        }
    }
}


import java.math.BigInteger;
import java.util.Scanner;

public class Prob1 {
    public static void main(String[] args) {
        Scanner scanner= new Scanner(System.in);
        int t =scanner.nextInt();
        while (t-->0){
            int x,y,k;
            x=scanner.nextInt();
            y=scanner.nextInt();
            k=scanner.nextInt();

            BigInteger q = new BigInteger(x+"");
            BigInteger a = new BigInteger(y+"");
            BigInteger e = new BigInteger(k+"");

            BigInteger one = new BigInteger("1");

            BigInteger big1 = a.multiply(e);

            BigInteger big[] = (((a.multiply(e)).add(e)).subtract(one)).divideAndRemainder(q.subtract(one));

            if(!big[1].equals(new BigInteger("0"))){
                BigInteger bigg = big[0].add(e.add(one));
                System.out.println(bigg);
                continue;
            }

            BigInteger bigg = big[0].add(e);
            System.out.println(bigg);
        }
    }
}


import java.math.BigInteger;
import java.util.Scanner;

public class Prob1 {
    public static void main(String[] args) {
        Scanner scanner= new Scanner(System.in);
        int t =scanner.nextInt();
        while (t-->0){
            int x,y,k;
            x=scanner.nextInt();
            y=scanner.nextInt();
            k=scanner.nextInt();

            BigInteger q=new BigInteger(x+"");
            BigInteger a = new BigInteger(y+"");
            BigInteger e = new BigInteger(k+"");
            BigInteger one = new BigInteger("1");
            BigInteger big1 = a.multiply(e);
            BigInteger big2 = big1.add(e);
            BigInteger big3 = big2.subtract(one);
            BigInteger[] big4 = big3.divideAndRemainder(q.subtract(one));
            if(!big4[1].equals(new BigInteger("0"))){
                BigInteger big5 = big4[0].add(e.add(one));
                System.out.println(big5);
                continue;
            }

            BigInteger big5 = big4[0].add(e);
            System.out.println(big4[0]);
        }
    }
}


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

public class problem1 {
    public static void main(String[] args) throws IOException {
        BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
        int t =  Integer.parseInt(br.readLine());
        while (t-->0){

            String[] s = br.readLine().split(" ");
            long x = Integer.parseInt(s[0]);
            long y = Integer.parseInt(s[1]);
            long z = Integer.parseInt(s[2]);

            long sticksreq = z + y*z;

            long count = (sticksreq -1)/(x-1);
            if ((sticksreq -1)%(x-1) != 0)
                count++;

            System.out.println(count+z);

        }

    }
}


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

public class problem1 {
    public static void main(String[] args) throws IOException {
        BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
        int t =  Integer.parseInt(br.readLine());
        while (t-->0){

            String[] s = br.readLine().split(" ");
            long x = Integer.parseInt(s[0]);
            long y = Integer.parseInt(s[1]);
            long z = Integer.parseInt(s[2]);

            long sticksreq = z + y*z;
            long currstick = 1;
            long count = (sticksreq -1)/(x-1);
//            while (currstick< sticksreq){
//
//                currstick= (currstick-1 + x);
//                count++;
//            }

            System.out.println(count+z);

        }

    }
}


/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		while(n>0)
		{
		    long s=1;
		    long c=0;
		    long x=sc.nextLong();
		    long y=sc.nextLong();
		    long k=sc.nextLong();
		    long req=y*k;
		    req=req+k;
		    req--;
		    long ans=k;
		    long gg=(req/(x-1));
		    if(req%(x-1)!=0)
		    ans++;

		    ans+=gg;
		    System.out.println(ans);
		}

	}
}


/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		while(n>0)
		{
		    long s=1;
		    long c=0;
		    long x=sc.nextLong();
		    long y=sc.nextLong();
		    long k=sc.nextLong();
		    long req=y*k;
		    req=req+k;
		    req--;
		    long ans=k;
		    long gg=(req/(x-1));
		    if(req%(x-1)!=0)
		    ans++;

		    ans+=gg;
		    System.out.println(ans);
		    n--;
		}

	}
}


import java.util.*;

public class A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int testCases = sc.nextInt();
        for (int t = 0; t < testCases; t++) {
            long x = sc.nextInt();
            long y = sc.nextInt();
            long k = sc.nextInt();

            // For k k sticks and k and coals
            // For y sticks 1 coal
            long sticksForCoal = y * k;
            long coalStick = k;

            long trade = 0;

            long cs = 1;
            // while (cs <= coalStick) {
            // cs = (cs - 1) + x;
            // trade++;
            // }

            trade = (long) Math.ceil(((double) cs - coalStick) / (1 - x));
            long val = cs - trade + trade * x;
            if (val <= coalStick) {
                trade++;
                cs = cs - trade + trade * x;
            } else {
                cs = val;
            }

            long leftStick = cs - coalStick;

            // while (cc < sticksForCoal) {
            // cc = (cc - 1) + x;
            // trade++;
            // }

            // trade += (long) Math.ceil(((double) leftStick - sticksForCoal) / (1 - x));

            long prod = (leftStick - sticksForCoal) / (1 - x);
            val = leftStick - prod + prod * x;
            if (val < sticksForCoal) {
                trade += prod + 1;
            } else {
                trade += prod;
            }

            sb.append(trade + k).append("\n");
        }
        System.out.print(sb);
    }

}


import java.util.*;

public class A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int testCases = sc.nextInt();
        for (int t = 0; t < testCases; t++) {
            long x = sc.nextInt();
            long y = sc.nextInt();
            long k = sc.nextInt();

            // For k k sticks and k and coals
            // For y sticks 1 coal
            long sticksForCoal = y * k;
            long coalStick = k;

            long trade = 0;

            long cs = 1;
            // while (cs <= coalStick) {
            // cs = (cs - 1) + x;
            // trade++;
            // }

            trade = (long) Math.ceil(((double) cs - coalStick) / (1 - x));
            cs = cs - trade + trade * x;

            long leftStick = cs - coalStick;
            long cc = leftStick;

            // while (cc < sticksForCoal) {
            // cc = (cc - 1) + x;
            // trade++;
            // }

            trade += (long) Math.ceil(((double) cc - sticksForCoal) / (1 - x));

            sb.append(trade + k).append("\n");
        }
        System.out.print(sb);
    }

}


import java.util.Scanner;

import javax.swing.plaf.basic.BasicScrollPaneUI.HSBChangeListener;

public class phela {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner s = new Scanner(System.in);
		int t = s.nextInt();

		while(t-->0) {

			int x = s.nextInt();
			int y = s.nextInt();
			int k = s.nextInt();

			long sticks_req = 1l*y*k + k;

			long count=0;
			long have = 1;
			while(have<sticks_req) {

				long num = have*x;
				if(num - sticks_req >0 || num<0 ) {
					count += (long)Math.ceil(1.0*(sticks_req - have)/(x-1));
					have = sticks_req;
				}
				else {
					count += have;
					have = 1L*have*x;
				}
			}
			long ans = k + count;

			System.out.println(ans);
		}
	}

}


import java.util.Scanner;

import javax.swing.plaf.basic.BasicScrollPaneUI.HSBChangeListener;

public class phela {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner s = new Scanner(System.in);
		int t = s.nextInt();

		while(t-->0) {

			int x = s.nextInt();
			int y = s.nextInt();
			int k = s.nextInt();

			long sticks_req = 1l*y*k + k;

			long count=0;
			long have = 1;
			while(have<sticks_req) {

				long num = have*x;

				if( Math.ceil((1.0*sticks_req)/have) <= x ) {
					count += (long)Math.ceil(1.0*(sticks_req - have)/(x-1));
					have = sticks_req;
				}
				else {
					count += have;
					have = 1L*have*x;
				}
			}
			long ans = k + count;

			System.out.println(ans);
		}
	}

}


import java.util.Scanner;

import javax.swing.plaf.basic.BasicScrollPaneUI.HSBChangeListener;

public class phela {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner s = new Scanner(System.in);
		int t = s.nextInt();

		while(t-->0) {

			int x = s.nextInt();
			int y = s.nextInt();
			int k = s.nextInt();

			long sticks_req = 1l*y*k + k;

			long count=0;
			long have = 1;
			while(have<sticks_req) {

				long num = have*x;

				if(sticks_req/have <x ) {
					count += (long)Math.ceil(1.0*(sticks_req - have)/(x-1));
					have = sticks_req;
				}
				else {
					count += have;
					have = 1L*have*x;
				}
			}
			long ans = k + count;

			System.out.println(ans);
		}
	}

}


import java.util.Scanner;

public class phela {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner s = new Scanner(System.in);
		int t = s.nextInt();

		while(t-->0) {

			int x = s.nextInt();
			int y = s.nextInt();
			int k = s.nextInt();

			long sticks_req = 1l*y*k + k;

			long count=0;
			long have = 1;
			while(have<sticks_req) {

				if( sticks_req/have < x ) {

					long remain = (sticks_req - have)/(x-1);

					if(remain*(x-1) + have < sticks_req) {
						count++;
					}
					count += (sticks_req - have)/(x-1);
					break;
				}
				else {
					count += have;
					have = 1L*have*x;
				}
			}
			long ans = k + count;

			System.out.println(ans);
		}
	}
}


//dassssssssssssssssssssssss
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
// Working program using Reader Class
//sadasd
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
public class onlyArray {

	public static void main(String[] args) {
		FastReader s=new FastReader();
     int t=s.nextInt();
     while(t>0) {
    	  long x=s.nextLong();
    	  long y=s.nextLong();
    	  long n=s.nextLong();
    	  long count=0;
    	  count+=n;
    	  if((y*n-1+n)%(x-1)==0) {
    		  count+=(y*n-1+n)/(x-1);
    	  }else {
    		  count+=(((y*n-1+n)/(x-1)))+1;
    	  }
//    	  count+=Math.ceil((y*n-x+n)/(x-1))+1;
    	  System.out.println(count);

    	 t--;
     }

}

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


//dassssssssssssssssssssssss
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
// Working program using Reader Class
//sadasd
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
public class onlyArray {

	public static void main(String[] args) {
		FastReader s=new FastReader();
     int t=s.nextInt();
     while(t>0) {
    	  long x=s.nextLong();
    	  long y=s.nextLong();
    	  long n=s.nextLong();
    	  long count=0;
    	  count+=n;
    	  if((y*n-x+n)%(x-1)==0) {
    		  count+=(y*n-x+n)/(x-1)+1;
    	  }else {
    		  count+=((y*n-x+n)/(x-1))+2;
    	  }
//    	  count+=Math.ceil((y*n-x+n)/(x-1))+1;
    	  System.out.println(count);

    	 t--;
     }

}

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


//dassssssssssssssssssssssss
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
// Working program using Reader Class
//sadasd
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
public class onlyArray {

	public static void main(String[] args) {
		FastReader s=new FastReader();
     int t=s.nextInt();
     while(t>0) {
    	  long x=s.nextLong();
    	  long y=s.nextLong();
    	  long n=s.nextLong();
    	  long count=0;
    	  count+=n;
    	  if((y*n-x+n)%(x-1)==0) {
    		  count+=(y*n-x+n)/(x-1)+1;
    	  }else {
    		  count+=Math.ceil(((y*n-x+n)/(x-1)))+1;
    	  }
//    	  count+=Math.ceil((y*n-x+n)/(x-1))+1;
    	  System.out.println(count);

    	 t--;
     }

}

	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.*;
import java.io.*;

public final class Codechef {
	static Scanner sc=new Scanner(System.in);
	static FastReader re=new FastReader();
	static PrintWriter writer=new PrintWriter(System.out);

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

		writer.flush();
		writer.close();
  }
	static void iAin(int[] a, int n) {
		for(int i=0;i<n;i++) a[i]=sc.nextInt();
	}
	static void lAin(long[] a, int n) {
		for(int i=0;i<n;i++) a[i]=sc.nextLong();
	}

	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.*;
import java.io.*;

public final class Codechef {
	static Scanner sc=new Scanner(System.in);
	static FastReader re=new FastReader();
	static PrintWriter writer=new PrintWriter(System.out);

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

		writer.flush();
		writer.close();
  }
	static void iAin(int[] a, int n) {
		for(int i=0;i<n;i++) a[i]=sc.nextInt();
	}
	static void lAin(long[] a, int n) {
		for(int i=0;i<n;i++) a[i]=sc.nextLong();
	}

	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.io.*;
import java.util.*;

public class A
{
    static long x, y, k;
    static int[] arr;
    static char[] s;
    public static void main(String[] args) throws IOException
    {
        Flash f = new Flash();
        int T = f.ni();
        for(int tc = 1; tc <= T; tc++){
            x = f.ni(); y = f.ni(); k = f.ni();
            sop(fn());
        }
    }

    static long fn()
    {
        long need = k*y+k-1;
        long ans = (need+x-2)/(x-1);
        return ans+k;
    }

    static void sort(int[] a){
        List<Integer> A = new ArrayList<>();
        for(int i : a) A.add(i);
        Collections.sort(A);
        for(int i = 0; i < A.size(); i++) a[i] = A.get(i);
    }

    static int swap(int itself, int dummy){
        return itself;
    }

    static void sop(Object o){ System.out.println(o); }

    static void print(int[] a){
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < a.length; i++) sb.append(a[i] + " ");
        System.out.println(sb);
    }

    static class Flash
    {
        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();
        }

        String ns(){
            String s = new String();
            try{
                s = br.readLine().trim();
            }catch(IOException e){
                e.printStackTrace();
            }

            return s;
        }

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

        int[] arr(int n){
            int[] a = new int[n];
            for(int i = 0; i < n; i++) a[i] = ni();
            return a;
        }

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

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


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

public class A
{
    static long n, x, y, k;
    static int[] arr;
    static String str;
    public static void main(String[] args) throws IOException
    {
        Flash f = new Flash();

        int T = f.ni();
        for(int tc = 1; tc <= T; tc++){
            x = f.ni(); y = f.ni(); k = f.ni();
            System.out.println(fn());
        }
    }

    static long fn()
    {
        long need = k * y + k;
        long ans = ((need-1 + x-2) / (x-1));

        return ans + k;
    }

    static void sort(int[] a){
        List<Integer> A = new ArrayList<>();
        for(int i : a) A.add(i);
        Collections.sort(A);
        for(int i = 0; i < A.size(); i++) a[i] = A.get(i);
    }

    static int swap(int itself, int dummy)
    {
        return itself;
    }

    //SecondThread
    static class Flash
    {
        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();
        }

        String nextLine(){
            String s = new String();
            try{
                s = br.readLine().trim();
            }catch(IOException e){
                e.printStackTrace();
            }

            return s;
        }

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

        int[] arr(int n){
            int[] a = new int[n];
            for(int i = 0; i < n; i++) a[i] = ni();
            return a;
        }

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


import java.util.*;

public class helloworld {

	final static short x = 2;
	final static int y = 0;

	static int count(String str) {

		String strFind1 = "abacaba";
		int count = 0, fromIndex = 0;

		while ((fromIndex = str.indexOf(strFind1, fromIndex)) != -1 ){

		    count++;
		    fromIndex++;

		}

		return count;

		}

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int t = in.nextInt();
		for(int i = 0;i<t;i++) {
			long x = in.nextInt();
			long y = in.nextInt();
			long k = in.nextInt();

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

			if(r%(x-1)!=0) {
				trade++;

			}
			long e = (long) trade;
			long w = (long) k;

			System.out.println(e+w);

		}

//
//		int t = in.nextInt();
//		for(int i = 0;i<t;i++) {
//			int p = in.nextInt();
//			int f = in.nextInt();
//			int cnts= in.nextInt();
//			int cntw = in.nextInt();
//			int s = in.nextInt();
//			int w = in.nextInt();
//
//			if(s>w) {
//				int temp = w;
//				w=s;
//				s= temp;
//
//				int temp2 = cntw;
//				cntw= cnts;
//				cnts = temp2;
//
//			}
//
//			int s1 = Math.min(cnts, p/s);
//			int w1 = Math.min(cntw, (p-(s1*s))/w);
//
//			int s2 = Math.min(cnts-s1, f/s);
//
//			int w2 = Math.min(cntw-w1, (f-(s2*s))/w);
//
//			int r = f- (s2*s) - (w2*w);
//			int r1 = p- (s1*s) - (w1*w);
//
//			int r2 = Math.min(cnts-s1-s2, (r+r1)/s);
//			int r3 = Math.min(cntw-w1-w2, ((r+r1)-(r2*s))/w);
//
//
//			System.out.println(s1+s2+w1+w2+ r2+r3);
//
//
//
//
//		}
//			int n = in.nextInt();
//
//			long cur = 0;
//
//			for(int j = 0;j<n;j++) {
//
//				long x = in.nextLong();
//				cur = Math.max(0, cur+x);
//			}
//			System.out.println(cur);
//
//
//		}

}

}


import java.util.*;

import q2.Reader;

public class helloworld {

	final static short x = 2;
	final static int y = 0;

	static int count(String str) {

		String strFind1 = "abacaba";
		int count = 0, fromIndex = 0;

		while ((fromIndex = str.indexOf(strFind1, fromIndex)) != -1 ){

		    count++;
		    fromIndex++;

		}

		return count;

		}

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int t = in.nextInt();
		for(int i = 0;i<t;i++) {
			long x = in.nextInt();
			long y = in.nextInt();
			long k = in.nextInt();

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

			if(r%(x-1)!=0) {
				trade++;

			}
			long e = (long) trade;
			long w = (long) k;

			System.out.println(e+w);

		}

//
//		int t = in.nextInt();
//		for(int i = 0;i<t;i++) {
//			int p = in.nextInt();
//			int f = in.nextInt();
//			int cnts= in.nextInt();
//			int cntw = in.nextInt();
//			int s = in.nextInt();
//			int w = in.nextInt();
//
//			if(s>w) {
//				int temp = w;
//				w=s;
//				s= temp;
//
//				int temp2 = cntw;
//				cntw= cnts;
//				cnts = temp2;
//
//			}
//
//			int s1 = Math.min(cnts, p/s);
//			int w1 = Math.min(cntw, (p-(s1*s))/w);
//
//			int s2 = Math.min(cnts-s1, f/s);
//
//			int w2 = Math.min(cntw-w1, (f-(s2*s))/w);
//
//			int r = f- (s2*s) - (w2*w);
//			int r1 = p- (s1*s) - (w1*w);
//
//			int r2 = Math.min(cnts-s1-s2, (r+r1)/s);
//			int r3 = Math.min(cntw-w1-w2, ((r+r1)-(r2*s))/w);
//
//
//			System.out.println(s1+s2+w1+w2+ r2+r3);
//
//
//
//
//		}
//			int n = in.nextInt();
//
//			long cur = 0;
//
//			for(int j = 0;j<n;j++) {
//
//				long x = in.nextLong();
//				cur = Math.max(0, cur+x);
//			}
//			System.out.println(cur);
//
//
//		}

}

}


import java.util.*;
import java.io.*;
public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st;
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;

	static String ns() throws IOException
    {
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    }

	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    {
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    }

	static long nl() throws IOException
    {
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    }

	static double nd() throws IOException
    {
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    }

	static String nsl() throws IOException
    {
        String str = "";
        try
        {
            str = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return str;
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }

	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }

	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int n) throws IOException
	{
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=ni();

		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();

		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();

		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{

				return this.h-n.h;
		}

	}

	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;

	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }

	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];

	  public static void main(String args[]) throws IOException {
		int t=ni();
		while(t-->0)
		{
			long x=nl(),y=nl(),k=nl();
			long count=0;
			long temp=k+(y*k);
			long ans=0;

			long val=(temp-x)/(x-1);

			if(((temp-x)%(x-1))==0)
				pn(val+k+1+"");
			else
				pn(val+2+k+"");

		}
		flush();
}
	  }


import java.util.*;
import java.io.*;
public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st;
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;

	static String ns() throws IOException
    {
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    }

	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    {
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    }

	static long nl() throws IOException
    {
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    }

	static double nd() throws IOException
    {
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    }

	static String nsl() throws IOException
    {
        String str = "";
        try
        {
            str = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return str;
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }

	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }

	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int n) throws IOException
	{
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
			arr[i]=ni();

		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();

		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();

		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{

				return this.h-n.h;
		}

	}

	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;

	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }

	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];

	  public static void main(String args[]) throws IOException {
		int t=ni();
		while(t-->0)
		{
			long x=nl(),y=nl(),k=nl();
			long count=0;
			long temp=k+(y*k);
			long ans=0;

			long val=(temp-x)/(x-1);
			long rem=(temp-x)%(x-1);
			if(rem==0)
				pn(val+k+1+"");
			else
				pn(val+2+k+"");

		}
		flush();
}
	  }