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

public class Main {

    public static void main(String[] args) {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    }
} import java.util.ArrayList; ArrayList java.util import java.util.List; List java.util import java.util.Scanner; Scanner java.util public class Main {

    public static void main(String[] args) {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    }
} Main public static void main(String[] args) {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    } main {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    } Scanner sc = new Scanner(System.in); sc new Scanner(System.in) int A = sc.nextInt(); A sc.nextInt() sc.nextInt sc int B = sc.nextInt(); B sc.nextInt() sc.nextInt sc int K = sc.nextInt(); K sc.nextInt() sc.nextInt sc sc.close() sc.close sc ArrayList<Integer> factoringA = new ArrayList<>(); factoringA new ArrayList<>() ArrayList<Integer> factoringB = new ArrayList<>(); factoringB new ArrayList<>() if (A > B) {int temp = A; A=B; B = temp;} A > B A B {int temp = A; A=B; B = temp;} int temp = A; temp A A=B A B B = temp B temp for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        } int n = 1; int n = 1; n 1 n < A+1 n A+1 A 1 n++ n++ n {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        } {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        } if(A % n == 0) {

                factoringA.add(n);
            } A % n == 0 A % n A n 0 {

                factoringA.add(n);
            } factoringA.add(n) factoringA.add factoringA n if(B % n == 0) {

                factoringB.add(n);
            } B % n == 0 B % n B n 0 {

                factoringB.add(n);
            } factoringB.add(n) factoringB.add factoringB n List<Integer> commonDivisorList = new ArrayList<>(); commonDivisorList new ArrayList<>() for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        } int a = 0; int a = 0; a 0 a < factoringA.size() a factoringA.size() factoringA.size factoringA a++ a++ a {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        } {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        } for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            } int b = 0; int b = 0; b 0 b < factoringB.size() b factoringB.size() factoringB.size factoringB b++ b++ b {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            } {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            } if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                } factoringA.get(a).equals(factoringB.get(b)) factoringA.get(a).equals factoringA.get(a) factoringA.get factoringA a factoringB.get(b) factoringB.get factoringB b {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                } commonDivisorList.add(factoringA.get(a)) commonDivisorList.add commonDivisorList factoringA.get(a) factoringA.get factoringA a continue; System.out.println(commonDivisorList.get(commonDivisorList.size() - K)) System.out.println System.out System System.out commonDivisorList.get(commonDivisorList.size() - K) commonDivisorList.get commonDivisorList commonDivisorList.size() - K commonDivisorList.size() commonDivisorList.size commonDivisorList K String[] args args public class Main {

    public static void main(String[] args) {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    }
} public class Main {

    public static void main(String[] args) {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    }
} Main
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
    	
    	//入力値の格納
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();
        int B = sc.nextInt();
        int K = sc.nextInt();

        sc.close();

        //A<BとおいてAの数だけAとBの約数を求める
        ArrayList<Integer> factoringA = new ArrayList<>();
        ArrayList<Integer> factoringB = new ArrayList<>();

        if (A > B) {int temp = A; A=B; B = temp;}

        for(int n = 1; n < A+1 ; n++) {

            if(A % n == 0) {

                factoringA.add(n);
            }

            if(B % n == 0) {

                factoringB.add(n);
            }
        }

        //AとBの公約数のリスト
        List<Integer> commonDivisorList = new ArrayList<>();

        //Aの約数の数だけループさせる
        for (int a = 0; a < factoringA.size(); a++ ) {
        	
        	//上で求めたBの約数の数だけループさせる
            for (int b = 0; b < factoringB.size(); b++) {
            	
            	//a番目のAの約数がBの約数の内に存在するか総当りで求める、見つかったらcontinue
                if (factoringA.get(a).equals(factoringB.get(b))) {

                    commonDivisorList.add(factoringA.get(a));
                    continue;
                }
            }
        }
        //commonDivisorListは昇順 => -(-commonDivisorListの要素数 + K)番目が最大公約数からK番目に大きい数
        System.out.println(commonDivisorList.get(commonDivisorList.size() - K));

    }
}