class Solution:

    # 定义一个名为 sortArray 的方法，接受一个整数列表 nums，返回一个排序后的整数列表

    def sortArray(self, nums: List[int]) -> List[int]:

        # 定义冒泡排序的函数

        def bubbleSort(nums):

            # 获取列表的长度

            n = len(nums)

            # 外层循环控制需要比较的轮数，每轮将当前最大的元素移动到末尾

            for i in range(n - 1):

                # 内层循环控制每轮比较的次数

                for j in range(n - i - 1):

                    # 如果当前元素大于下一个元素，交换它们的位置

                    if nums[j] > nums[j + 1]:

                        nums[j], nums[j + 1] = nums[j + 1], nums[j]

            # 返回排序后的列表

            return nums

        # 调用冒泡排序函数并返回结果

        return bubbleSort(nums)

class Solution:

    # 定义一个名为 searchMatrix 的方法，接受一个二维数组 matrix 和一个整数 target，返回一个布尔值

    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:

        # 获取二维数组的行数和列数

        m, n = len(matrix), len(matrix[0])

        # 初始化起始搜索位置为二维数组的左下角

        row, col = m - 1, 0

        # 使用循环进行搜索，直到搜索越界或找到目标值

        while row >= 0 and col < n:

            # 如果当前元素大于目标值，向上移动一行

            if matrix[row][col] > target:

                row -= 1

            # 如果当前元素小于目标值，向右移动一列

            elif matrix[row][col] < target:

                col += 1

            # 如果当前元素等于目标值，返回 True

            else:

                return True

        # 如果循环结束仍未找到目标值，返回 False

        return False

# 定义计算最大公约数的函数

def gcd(a, b):

    # 使用欧几里德算法，直到其中一个数为 0

    while b != 0:

        # 交换两个数的值，并取余数

        a, b = b, a % b

    # 返回最大公约数

    return a

# 定义计算最小公倍数的函数

def lcm(a, b):

    # 两个数的最小公倍数等于两个数的乘积除以它们的最大公约数

    return a * b // gcd(a, b)

# 获取用户输入的两个正整数

m = int(input("请输入第一个正整数 m："))

n = int(input("请输入第二个正整数 n："))

# 调用函数计算最大公约数和最小公倍数，并打印结果

print("最大公约数是：", gcd(m, n))

print("最小公倍数是：", lcm(m, n))