// タンピン二盃口が成立しているかを判定する。
// 鳴き、カン、七対子形、国士形はタンピン二盃口と両立しないので最初から考慮しない。
// ツモピンフあり、大車輪ありとする。
 
open System.Text.RegularExpressions
open System.Collections.Generic
 
let input() =
    printfn "Manzu:1m-9m Pinzu:1p-9p Souzu:1s-9s Jihai:1j-7j (The last input means 'Agari Hai')"
    let inp = System.Console.ReadLine()
    match Regex.Match(inp, @"\A\s*(?:([1-9][mps]|[1-7]j)\s*){14}\Z") with
    | m when m.Success ->
        let hais =
            m.Groups.[1].Captures |> Seq.cast<Capture>
            |> Seq.map (fun c -> c.Value.[1], int c.Value.[.. 0]) |> Seq.toList
        let agariHai = hais |> List.rev |> List.head
        let haiCountMap = hais |> Seq.countBy id |> Map.ofSeq
        if haiCountMap |> Map.forall (fun _ -> (>=) 4) then Some(haiCountMap, agariHai) else None
    | _ -> None
 
let getAllMentsu haiCountMap agariHai =
    let tryRemoveCount n key map =
        map |> Map.tryFind key |> Option.bind (function
            | c when c > n -> map |> Map.add key (c - n) |> Some
            | c when c = n -> map |> Map.remove key |> Some
            | _ -> None)
 
    let tryTakeSame count haiCountMap (hai : char * int) =
        tryRemoveCount count hai haiCountMap |> Option.map (fun m -> Map.ofList [hai, count], m)
 
    let tryTakeShuntsu haiCountMap (suit, num) =
        if suit = 'j' then None else
        (Some haiCountMap, [num .. num + 2])
        ||> List.fold (fun m n -> m |> Option.bind (tryRemoveCount 1 (suit, n)))
        |> Option.map (fun m -> Map.ofList [for n in num .. num + 2 -> (suit, n), 1], m)
 
    let memo = HashSet(HashIdentity.Structural)
    let rec getMentsu haiCountMap mentsus =
        if memo.Add(haiCountMap, List.sort mentsus) |> not then Seq.empty
        elif Map.isEmpty haiCountMap then
            let mentsus = mentsus |> List.rev
            mentsus |> Seq.mapi (fun i m -> i, m) |> Seq.choose (fun (i, mentsu) ->
                tryRemoveCount 1 agariHai mentsu |> Option.map (fun m ->
                    mentsus |> List.mapi (fun j mentsu -> if j = i then m else mentsu)))
            |> Seq.map (fun (jantou::rest) -> jantou::List.sortBy Seq.length rest)
        elif List.isEmpty mentsus then
            haiCountMap |> Map.toSeq |> Seq.choose (fst >> tryTakeSame 2 haiCountMap)
            |> Seq.collect (fun (jantou, rest) -> getMentsu rest [jantou])
        else
            haiCountMap |> Map.toSeq |> Seq.collect (fun (hai, _) ->
                [tryTakeSame 3; tryTakeShuntsu] |> Seq.choose (fun f-> f haiCountMap hai)
                |> Seq.collect (fun (mentsu, rest) -> getMentsu rest (mentsu::mentsus)))
 
    getMentsu haiCountMap []
 
let isYaochuu = function 'j', _ | _, 1 | _, 9 -> false | _ -> true
 
let isTanyao agariHai mentsus =
    mentsus |> List.forall (Map.toSeq >> Seq.forall (fst >> isYaochuu)) && isYaochuu agariHai
 
let isPinfu agariHai (jantou::taatsu::rest) =
    let isSequence count mentsu =
        let hais = mentsu |> Map.toSeq |> Seq.toList
        List.length hais = count
        && hais |> Seq.map (fst >> snd) |> Seq.sort |> Seq.pairwise
            |> Seq.map ((<||) (-)) |> Seq.forall ((=) -1)
 
    jantou |> Map.forall (fun _ -> (=) 2) && taatsu |> isSequence 2
    && rest |> List.forall (isSequence 3)
 
let isRyanpeikou agariHai (jantou::taatsu::rest) =
    let mentsus =
        if jantou |> Map.forall (fun _ -> (=) 1) then taatsu::rest else
        let c = Map.tryFind agariHai taatsu in Map.add agariHai (defaultArg c 0 + 1) taatsu::rest
    let counts = mentsus |> Seq.countBy id |> Seq.toList
    (List.length counts = 2 && counts |> List.forall (snd >> (=) 2))
    || (List.length counts = 1 && counts |> List.forall (snd >> (=) 4))
 
let isDaisharin agariHai =
    List.collect (Map.toList >> List.collect (fun (hai, count) -> List.replicate count hai))
    >> (fun hais -> agariHai::hais) >> Seq.countBy id >> Seq.toList >> List.unzip
    >> fun (hais, counts) ->
        let suits, nums = List.unzip hais
        suits |> Seq.distinct |> Seq.length |> (=) 1 && Seq.head suits <> 'j'
        && nums |> List.forall (fun num -> 1 < num && num < 9)
        && counts |> List.forall ((=) 2)
 
let main() =
    match input() with
    | Some(haiCountMap, agariHai) ->
        getAllMentsu haiCountMap agariHai |> Seq.exists (fun mentsus ->
            [isTanyao agariHai; isPinfu agariHai; isRyanpeikou agariHai; isDaisharin agariHai >> not]
            |> List.forall ((|>) mentsus))
        |> printfn "%O"
    | _ -> printfn "Illegal input"
 
main()

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

Mm0ybTNtM200bTRtIDVwNXAgNnM2czdzN3M4cyA4cw==

2m2m3m3m4m4m 5p5p 6s6s7s7s8s 8s