let solve() =
    let permutation k ls =
        let rec p a b = function
            | _, [] | 0, _ -> a::b
            | k, ls -> List.fold (fun x y -> p (y::a) x (k - 1, List.filter ((<>) y) ls)) b ls
        p [] [] (k, ls)
    let rec gcd = function x, 0 -> x | x, y -> gcd (y, x % y)
    let add x xs =
        seq { for i in 0 .. List.length xs ->
                [Seq.take i xs; Seq.singleton x; Seq.skip i xs] |> Seq.concat |> Seq.toList }
    let toNumbers x = add x >> Seq.map (List.reduce (fun x y -> x * 10 + y))
    let toDigits = Seq.unfold (function 0 -> None | x -> Some(x % 10, x / 10)) >> Seq.sort >> Seq.toList
    let digits = set [1 .. 9]
    [for d in 2 .. 9 do
     for n in 1 .. d - 1 do
        if gcd (d, n) = 1 then yield! [for k in 1 .. 7 -> (n, d, k)]]
    |> Seq.collect (fun (n, d, k) ->
        digits |> Set.remove n |> Set.remove d |> Set.toList |> permutation k
        |> Seq.collect (fun ps ->
            let ds = d::ps |> List.sort
            ps |> toNumbers n |> Seq.choose (fun nf -> if nf % n = 0 then Some(nf, nf / n * d) else None)
            |> Seq.filter (fun (nf, df) -> let g = gcd (df, nf) in nf / g = n && df / g = d && toDigits df = ds)))