Book {
    defs: {
        Name(
            "main",
        ): Definition {
            name: Name(
                "main",
            ),
            rules: [
                Rule {
                    pats: [],
                    body: App {
                        tag: Static,
                        fun: App {
                            tag: Static,
                            fun: Ref {
                                nam: Name(
                                    "String/Cons",
                                ),
                            },
                            arg: Num {
                                val: U24(
                                    72,
                                ),
                            },
                        },
                        arg: App {
                            tag: Static,
                            fun: App {
                                tag: Static,
                                fun: Ref {
                                    nam: Name(
                                        "String/Cons",
                                    ),
                                },
                                arg: Num {
                                    val: U24(
                                        101,
                                    ),
                                },
                            },
                            arg: App {
                                tag: Static,
                                fun: App {
                                    tag: Static,
                                    fun: Ref {
                                        nam: Name(
                                            "String/Cons",
                                        ),
                                    },
                                    arg: Num {
                                        val: U24(
                                            108,
                                        ),
                                    },
                                },
                                arg: App {
                                    tag: Static,
                                    fun: App {
                                        tag: Static,
                                        fun: Ref {
                                            nam: Name(
                                                "String/Cons",
                                            ),
                                        },
                                        arg: Num {
                                            val: U24(
                                                108,
                                            ),
                                        },
                                    },
                                    arg: App {
                                        tag: Static,
                                        fun: App {
                                            tag: Static,
                                            fun: Ref {
                                                nam: Name(
                                                    "String/Cons",
                                                ),
                                            },
                                            arg: Num {
                                                val: U24(
                                                    111,
                                                ),
                                            },
                                        },
                                        arg: App {
                                            tag: Static,
                                            fun: App {
                                                tag: Static,
                                                fun: Ref {
                                                    nam: Name(
                                                        "String/Cons",
                                                    ),
                                                },
                                                arg: Num {
                                                    val: U24(
                                                        44,
                                                    ),
                                                },
                                            },
                                            arg: App {
                                                tag: Static,
                                                fun: App {
                                                    tag: Static,
                                                    fun: Ref {
                                                        nam: Name(
                                                            "String/Cons",
                                                        ),
                                                    },
                                                    arg: Num {
                                                        val: U24(
                                                            32,
                                                        ),
                                                    },
                                                },
                                                arg: App {
                                                    tag: Static,
                                                    fun: App {
                                                        tag: Static,
                                                        fun: Ref {
                                                            nam: Name(
                                                                "String/Cons",
                                                            ),
                                                        },
                                                        arg: Num {
                                                            val: U24(
                                                                87,
                                                            ),
                                                        },
                                                    },
                                                    arg: App {
                                                        tag: Static,
                                                        fun: App {
                                                            tag: Static,
                                                            fun: Ref {
                                                                nam: Name(
                                                                    "String/Cons",
                                                                ),
                                                            },
                                                            arg: Num {
                                                                val: U24(
                                                                    111,
                                                                ),
                                                            },
                                                        },
                                                        arg: App {
                                                            tag: Static,
                                                            fun: App {
                                                                tag: Static,
                                                                fun: Ref {
                                                                    nam: Name(
                                                                        "String/Cons",
                                                                    ),
                                                                },
                                                                arg: Num {
                                                                    val: U24(
                                                                        114,
                                                                    ),
                                                                },
                                                            },
                                                            arg: App {
                                                                tag: Static,
                                                                fun: App {
                                                                    tag: Static,
                                                                    fun: Ref {
                                                                        nam: Name(
                                                                            "String/Cons",
                                                                        ),
                                                                    },
                                                                    arg: Num {
                                                                        val: U24(
                                                                            108,
                                                                        ),
                                                                    },
                                                                },
                                                                arg: App {
                                                                    tag: Static,
                                                                    fun: App {
                                                                        tag: Static,
                                                                        fun: Ref {
                                                                            nam: Name(
                                                                                "String/Cons",
                                                                            ),
                                                                        },
                                                                        arg: Num {
                                                                            val: U24(
                                                                                100,
                                                                            ),
                                                                        },
                                                                    },
                                                                    arg: App {
                                                                        tag: Static,
                                                                        fun: App {
                                                                            tag: Static,
                                                                            fun: Ref {
                                                                                nam: Name(
                                                                                    "String/Cons",
                                                                                ),
                                                                            },
                                                                            arg: Num {
                                                                                val: U24(
                                                                                    33,
                                                                                ),
                                                                            },
                                                                        },
                                                                        arg: Ref {
                                                                            nam: Name(
                                                                                "String/Nil",
                                                                            ),
                                                                        },
                                                                    },
                                                                },
                                                            },
                                                        },
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            ],
            builtin: false,
        },
        Name(
            "String/Nil",
        ): Definition {
            name: Name(
                "String/Nil",
            ),
            rules: [
                Rule {
                    pats: [],
                    body: Lam {
                        tag: Static,
                        pat: Var(
                            Some(
                                Name(
                                    "a",
                                ),
                            ),
                        ),
                        bod: App {
                            tag: Static,
                            fun: Var {
                                nam: Name(
                                    "a",
                                ),
                            },
                            arg: Ref {
                                nam: Name(
                                    "String/Nil/tag",
                                ),
                            },
                        },
                    },
                },
            ],
            builtin: true,
        },
        Name(
            "String/Cons",
        ): Definition {
            name: Name(
                "String/Cons",
            ),
            rules: [
                Rule {
                    pats: [],
                    body: Lam {
                        tag: Static,
                        pat: Var(
                            Some(
                                Name(
                                    "a",
                                ),
                            ),
                        ),
                        bod: Lam {
                            tag: Static,
                            pat: Var(
                                Some(
                                    Name(
                                        "b",
                                    ),
                                ),
                            ),
                            bod: Lam {
                                tag: Static,
                                pat: Var(
                                    Some(
                                        Name(
                                            "c",
                                        ),
                                    ),
                                ),
                                bod: App {
                                    tag: Static,
                                    fun: App {
                                        tag: Static,
                                        fun: App {
                                            tag: Static,
                                            fun: Var {
                                                nam: Name(
                                                    "c",
                                                ),
                                            },
                                            arg: Ref {
                                                nam: Name(
                                                    "String/Cons/tag",
                                                ),
                                            },
                                        },
                                        arg: Var {
                                            nam: Name(
                                                "a",
                                            ),
                                        },
                                    },
                                    arg: Var {
                                        nam: Name(
                                            "b",
                                        ),
                                    },
                                },
                            },
                        },
                    },
                },
            ],
            builtin: true,
        },
        Name(
            "String/Nil/tag",
        ): Definition {
            name: Name(
                "String/Nil/tag",
            ),
            rules: [
                Rule {
                    pats: [],
                    body: Num {
                        val: U24(
                            0,
                        ),
                    },
                },
            ],
            builtin: true,
        },
        Name(
            "String/Cons/tag",
        ): Definition {
            name: Name(
                "String/Cons/tag",
            ),
            rules: [
                Rule {
                    pats: [],
                    body: Num {
                        val: U24(
                            1,
                        ),
                    },
                },
            ],
            builtin: true,
        },
    },
    adts: {
        Name(
            "String",
        ): Adt {
            ctrs: {
                Name(
                    "String/Nil",
                ): [],
                Name(
                    "String/Cons",
                ): [
                    CtrField {
                        nam: Name(
                            "head",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "tail",
                        ),
                        rec: true,
                    },
                ],
            },
            builtin: true,
        },
        Name(
            "List",
        ): Adt {
            ctrs: {
                Name(
                    "List/Nil",
                ): [],
                Name(
                    "List/Cons",
                ): [
                    CtrField {
                        nam: Name(
                            "head",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "tail",
                        ),
                        rec: true,
                    },
                ],
            },
            builtin: true,
        },
        Name(
            "Nat",
        ): Adt {
            ctrs: {
                Name(
                    "Nat/Succ",
                ): [
                    CtrField {
                        nam: Name(
                            "pred",
                        ),
                        rec: true,
                    },
                ],
                Name(
                    "Nat/Zero",
                ): [],
            },
            builtin: true,
        },
        Name(
            "Tree",
        ): Adt {
            ctrs: {
                Name(
                    "Tree/Node",
                ): [
                    CtrField {
                        nam: Name(
                            "left",
                        ),
                        rec: true,
                    },
                    CtrField {
                        nam: Name(
                            "right",
                        ),
                        rec: true,
                    },
                ],
                Name(
                    "Tree/Leaf",
                ): [
                    CtrField {
                        nam: Name(
                            "value",
                        ),
                        rec: false,
                    },
                ],
            },
            builtin: true,
        },
        Name(
            "Map",
        ): Adt {
            ctrs: {
                Name(
                    "Map/Node",
                ): [
                    CtrField {
                        nam: Name(
                            "value",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "left",
                        ),
                        rec: true,
                    },
                    CtrField {
                        nam: Name(
                            "right",
                        ),
                        rec: true,
                    },
                ],
                Name(
                    "Map/Leaf",
                ): [],
            },
            builtin: true,
        },
        Name(
            "IO",
        ): Adt {
            ctrs: {
                Name(
                    "IO/Done",
                ): [
                    CtrField {
                        nam: Name(
                            "magic",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "expr",
                        ),
                        rec: false,
                    },
                ],
                Name(
                    "IO/Call",
                ): [
                    CtrField {
                        nam: Name(
                            "magic",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "func",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "argm",
                        ),
                        rec: false,
                    },
                    CtrField {
                        nam: Name(
                            "cont",
                        ),
                        rec: false,
                    },
                ],
            },
            builtin: true,
        },
    },
    ctrs: {
        Name(
            "String/Nil",
        ): Name(
            "String",
        ),
        Name(
            "String/Cons",
        ): Name(
            "String",
        ),
        Name(
            "List/Nil",
        ): Name(
            "List",
        ),
        Name(
            "List/Cons",
        ): Name(
            "List",
        ),
        Name(
            "Nat/Succ",
        ): Name(
            "Nat",
        ),
        Name(
            "Nat/Zero",
        ): Name(
            "Nat",
        ),
        Name(
            "Tree/Node",
        ): Name(
            "Tree",
        ),
        Name(
            "Tree/Leaf",
        ): Name(
            "Tree",
        ),
        Name(
            "Map/Node",
        ): Name(
            "Map",
        ),
        Name(
            "Map/Leaf",
        ): Name(
            "Map",
        ),
        Name(
            "IO/Done",
        ): Name(
            "IO",
        ),
        Name(
            "IO/Call",
        ): Name(
            "IO",
        ),
    },
    entrypoint: Some(
        Name(
            "main",
        ),
    ),
}