package main

import (
	"fmt"
)

type iv struct {
	index, value int
}

func factor(n int) (f []int) {
	for i := 1; i*i <= n; i++ {
		if n%i == 0 {
			f = append(f, i)
			f = append(f, n/i)
		}
	}
	return
}

func main() {
	var N int
	fmt.Scan(&N)
	a := make([]int, N)
	for i := 0; i < N; i++ {
		fmt.Scan(&a[i])
	}

	if len(a) > 1 {
		lcmSort(a[0], a[1:])
	}
	ans := fmt.Sprintln(a)
	fmt.Println(ans[1 : len(ans)-2])
}

func lcmSort(key int, a []int) {
	if len(a) == 1 {
		return
	}

	f := factor(key)
	m := make(map[int][]iv)
	for i, v := range a {
		for _, d := range f {
			if v%d == 0 {
				m[d] = append(m[d], iv{i, v})
			}
		}
	}
	t := make([]iv, 0, len(m))
	for _, v := range m {
		t = append(t, min(v))
	}
	i := lcmMinIndex(key, t)
	a[0], a[i] = a[i], a[0]

	lcmSort(a[0], a[1:])
}
func lcmMinIndex(key int, a []iv) (m int) {
	for i := range a {
		if less(key, a, i, m) {
			m = i
		}
	}
	return a[m].index
}
func min(a []iv) (m iv) {
	m.value = 10000
	for _, v := range a {
		if v.value < m.value {
			m = v
		}
	}
	return
}
func less(key int, a []iv, i, j int) bool {
	lcmi := lcm(key, a[i].value)
	lcmj := lcm(key, a[j].value)
	if lcmi == lcmj {
		return a[i].value < a[j].value
	}
	return lcmi < lcmj
}
func lcm(a, b int) int {
	g := gcd(a, b)
	return (a / g) * (b / g) * g
}

func gcd(a, b int) int {
	if a > b {
		a, b = b, a
	}
	if a == 0 {
		return b
	}

	return gcd(b%a, a)
}