using System;
{
    //maybeエフェクトのハンドラ
    Maybe<int, string> maybe = new(){
        None = new(resume => "数字に変換できない文字です")
    };
    Console.WriteLine(ParseAdd("34", "14", maybe).Run(x => x.ToString()));
    Console.WriteLine(ParseAdd("34f", "14", maybe).Run(x => x.ToString()));
}

//文字列を数字に変える。
CC<int, T> Parse<T>(string str, Maybe<int, T> maybe) =>
    int.TryParse(str, out var num) ? CC.Return<int, T>(num) : maybe.None;

//2つの文字列を数字に変えて足す
CC<int, T> ParseAdd<T>(string left, string right, Maybe<int, T> maybe) =>
    from l in Parse<T>(left, maybe)
    from r in Parse<T>(right, maybe)
    select l + r;

public class Maybe<R, T> {
    public required CC<R, T> None{ get; init; }
}

//継続モナドの実装
public record CC<R, T>(Func<Func<R, T>, T> Run) {
    public CC<R2, T> Select<R2>(Func<R, R2> func) =>
        new(resume => Run(x => resume(func(x))));
    public CC<R2, T> SelectMany<R2>(Func<R, CC<R2, T>> func) =>
        new(resume => Run(x => func(x).Run(y => resume(y))));
    public CC<R3, T> SelectMany<R2, R3>(Func<R, CC<R2, T>> func,
                                        Func<R, R2, R3> func2) =>
        new(resume => Run(x => func(x).Run(y => resume(func2(x, y)))));
}

public static class CC{
    public static CC<R, T> Return<R, T>(R value) => new(f => f(value));
}

<script type="module">
    // 第一引数にユーザ名、第二引数に最大取得数
    const getUserActivity = async (user = 'griffpatch', max = 10000) => {
        const raw = await (
            await fetch(
                `https://scratch.mit.edu/messages/ajax/user-activity/?user=${user}&max=${max}`
            )
        ).text() // テキストデータとしてFetchで取得
        const html = new DOMParser().parseFromString(raw, 'text/html') // テキストをDOMに変換
        // li要素の中身を抽出して配列に戻す
        let result = []
        for (let item of html.querySelectorAll('li')) {
            item = item.querySelector('div')
            result.push({
                actor: item.querySelector('span.actor').textContent, // アクティビティをやった人みたいな感じでしょうか
                body: item.childNodes[2].data.trim(), // リミックスなどのアクティビティ内容
                href: item.querySelector('a').getAttribute('href'), // プロジェクトやスタジオのURL
                title: item.querySelector('a').textContent, // プロジェクトやスタジオのタイトル
                time: item.querySelector('span.time').textContent.trim() // タイムスタンプ
            })
        }
        return result // 結果を戻す
    }
    // この場合はmagicAhoさんのアクティビティを最大10000個取得するコードになります
    console.log(await getUserActivity('magicAho'))
</script>
<!-- (赤丸で囲まれているところがありますが、ScratchのフォーラムがJavaScriptのテンプレートリテラルに対応していないだけだと思うので安心して使って下さい) -->

type Cont<'r, 't>(run: ('r -> 't) -> 't) =
    member this.run = run

type ContBuilder() =
    member __.Return(x) = Cont(fun resume -> resume(x))
    member __.Bind<'a, 'b, 't>(m : Cont<'a, 't>, f: 'a -> Cont<'b, 't>) =
        Cont(fun resume -> m.run(fun x -> f(x).run(resume)))
    member __.ReturnFrom(x) = x

let cont = ContBuilder()

type Maybe<'a, 't> = {
    none: Cont<'a, 't>
}

let maybeLift<'a, 't>(maybe: Maybe<'a, 't>)(op: Option<'a>) =
    match op with
    | Some x -> cont{ return x }
    | None -> maybe.none

let safeDiv<'t> x y (maybe: Maybe<int, 't>) = cont{
    if y = 0 then
        return! maybe.none
    else
        return x / y
}

let runCont<'a> (cont: Cont<'a, 'a>) = cont.run(fun x -> x)

let rec each<'a, 't>(lst: List<'a>)(f: 'a -> Cont<unit, 'b>) =
    match lst with
    | x :: rem ->
        cont {
            do! f x
            do! each rem f
        }
    | [] -> cont { return () }

type Writer<'t> = {
    write: string -> Cont<unit, 't>
}

let earlyReturn<'a, 'b, 't>(body: ('a -> Cont<'b, 't>) -> Cont<'a, 't>) = Cont(fun resume -> body(fun x -> Cont(fun _ -> resume(x))).run(resume))

let runWriter<'a, 't>(f: Writer<'t> -> Cont<'a, 't>) =
    let mutable output = ""
    let writer = {write = fun x -> Cont(fun resume -> resume(output <- output + x)) }
    cont{
        let! v = f(writer)
        return (v, output)
    }

runWriter(fun writer -> earlyReturn <| fun ret -> cont{
    let maybe = {
        none = cont {
            do! writer.write("0で除算しました");
            return! ret ();
        }
    }
    do! each([3; 2; 0; 5])(fun x -> cont{
        let! a = safeDiv 10 x maybe
        do! writer.write <| $"10 / {x} = {a}\n"
    }) 
    do! writer.write "success"
    return ()
}).run(fun (_, s) -> printf "%s" s)

1回目: int型の変数で計算させようとする(オーバーフローするため間違い)
2回目: int64_t型の変数で計算させようとする(やはりオーバーフローする)
3回目: GMPライブラリを使用し、巨大な数の計算を可能にすることで無理やり解く

ここで、「a ≡ p(mod n)かつb ≡ q(mod n)なら、ab ≡ pq(mod n)」ということを教える

4回目: これを使用し、模範解答に非常に近いプログラムを生成する。

(println (read-line))