---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "pkgs",
                default: None,
            },
            FunctionArgument {
                identifier: "perl",
                default: None,
            },
            FunctionArgument {
                identifier: "openssl",
                default: None,
            },
            FunctionArgument {
                identifier: "pythonOlder",
                default: None,
            },
            FunctionArgument {
                identifier: "rustPlatform",
                default: None,
            },
            FunctionArgument {
                identifier: "buildPythonPackage",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchFromGitHub",
                default: None,
            },
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: LetIn {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "maturin_0_11",
                            position: (14, 3),
                        },
                    ],
                },
                With {
                    expression: Variable {
                        identifier: "pkgs",
                        position: (14, 23),
                    },
                    target: FunctionApplication {
                        function: PropertyAccess {
                            expression: Variable {
                                identifier: "rustPlatform",
                                position: (14, 29),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "buildRustPackage",
                                        position: (14, 42),
                                    },
                                ],
                            },
                            default: None,
                        },
                        arguments: [
                            Map {
                                bindings: [
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "pname",
                                                    position: (15, 5),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "maturin",
                                                    position: (15, 14),
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "version",
                                                    position: (16, 5),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "0.11.5",
                                                    position: (16, 16),
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "src",
                                                    position: (17, 5),
                                                },
                                            ],
                                        },
                                        FunctionApplication {
                                            function: Variable {
                                                identifier: "fetchFromGitHub",
                                                position: (17, 11),
                                            },
                                            arguments: [
                                                Map {
                                                    bindings: [
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "owner",
                                                                        position: (18, 7),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "PyO3",
                                                                        position: (18, 16),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "repo",
                                                                        position: (19, 7),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "maturin",
                                                                        position: (19, 15),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "rev",
                                                                        position: (20, 7),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "v",
                                                                        position: (20, 14),
                                                                    },
                                                                    Expression {
                                                                        expression: Variable {
                                                                            identifier: "version",
                                                                            position: (20, 17),
                                                                        },
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "hash",
                                                                        position: (21, 7),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "sha256-hwc6WObcJa6EXf+9PRByUtiupMMYuXThA8i/K4rl0MA=",
                                                                        position: (21, 15),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                    ],
                                                    recursive: false,
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "cargoHash",
                                                    position: (23, 5),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "sha256-qGCEfKpQwAC57LKonFnUEgLW4Cc7HFJgSyUOzHkKN9c=",
                                                    position: (23, 18),
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "nativeBuildInputs",
                                                    position: (26, 5),
                                                },
                                            ],
                                        },
                                        List {
                                            elements: [
                                                Variable {
                                                    identifier: "pkg-config",
                                                    position: (26, 27),
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "buildInputs",
                                                    position: (28, 5),
                                                },
                                            ],
                                        },
                                        BinaryOperation {
                                            operator: Concatenation,
                                            operands: [
                                                FunctionApplication {
                                                    function: PropertyAccess {
                                                        expression: Variable {
                                                            identifier: "lib",
                                                            position: (28, 19),
                                                        },
                                                        attribute_path: AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "optionals",
                                                                    position: (28, 23),
                                                                },
                                                            ],
                                                        },
                                                        default: None,
                                                    },
                                                    arguments: [
                                                        PropertyAccess {
                                                            expression: Variable {
                                                                identifier: "stdenv",
                                                                position: (28, 33),
                                                            },
                                                            attribute_path: AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "isLinux",
                                                                        position: (28, 40),
                                                                    },
                                                                ],
                                                            },
                                                            default: None,
                                                        },
                                                        List {
                                                            elements: [
                                                                Variable {
                                                                    identifier: "dbus",
                                                                    position: (28, 50),
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                                FunctionApplication {
                                                    function: PropertyAccess {
                                                        expression: Variable {
                                                            identifier: "lib",
                                                            position: (29, 10),
                                                        },
                                                        attribute_path: AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "optionals",
                                                                    position: (29, 14),
                                                                },
                                                            ],
                                                        },
                                                        default: None,
                                                    },
                                                    arguments: [
                                                        PropertyAccess {
                                                            expression: Variable {
                                                                identifier: "stdenv",
                                                                position: (29, 24),
                                                            },
                                                            attribute_path: AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "isDarwin",
                                                                        position: (29, 31),
                                                                    },
                                                                ],
                                                            },
                                                            default: None,
                                                        },
                                                        List {
                                                            elements: [
                                                                PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "darwin",
                                                                        position: (29, 42),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "apple_sdk",
                                                                                position: (29, 49),
                                                                            },
                                                                            Raw {
                                                                                content: "frameworks",
                                                                                position: (29, 59),
                                                                            },
                                                                            Raw {
                                                                                content: "Security",
                                                                                position: (29, 70),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                                Variable {
                                                                    identifier: "libiconv",
                                                                    position: (29, 79),
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "doCheck",
                                                    position: (32, 5),
                                                },
                                            ],
                                        },
                                        Variable {
                                            identifier: "false",
                                            position: (32, 15),
                                        },
                                    ),
                                ],
                                recursive: true,
                            },
                        ],
                    },
                },
            ),
        ],
        target: FunctionApplication {
            function: Variable {
                identifier: "buildPythonPackage",
                position: (36, 1),
            },
            arguments: [
                Map {
                    bindings: [
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "pname",
                                        position: (37, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "clvm_rs",
                                        position: (37, 12),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "version",
                                        position: (38, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "0.1.19",
                                        position: (38, 14),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "disabled",
                                        position: (39, 3),
                                    },
                                ],
                            },
                            FunctionApplication {
                                function: Variable {
                                    identifier: "pythonOlder",
                                    position: (39, 14),
                                },
                                arguments: [
                                    String {
                                        parts: [
                                            Raw {
                                                content: "3.7",
                                                position: (39, 27),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "src",
                                        position: (41, 3),
                                    },
                                ],
                            },
                            FunctionApplication {
                                function: Variable {
                                    identifier: "fetchFromGitHub",
                                    position: (41, 9),
                                },
                                arguments: [
                                    Map {
                                        bindings: [
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "owner",
                                                            position: (42, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "Chia-Network",
                                                            position: (42, 14),
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "repo",
                                                            position: (43, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "clvm_rs",
                                                            position: (43, 13),
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "rev",
                                                            position: (44, 5),
                                                        },
                                                    ],
                                                },
                                                Variable {
                                                    identifier: "version",
                                                    position: (44, 11),
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "sha256",
                                                            position: (45, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "sha256-mCKY/PqNOUTaRsFDxQBvbTD6wC4qzP0uv5FldYkwl6c=",
                                                            position: (45, 15),
                                                        },
                                                    ],
                                                },
                                            ),
                                        ],
                                        recursive: false,
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "cargoDeps",
                                        position: (48, 3),
                                    },
                                ],
                            },
                            FunctionApplication {
                                function: PropertyAccess {
                                    expression: Variable {
                                        identifier: "rustPlatform",
                                        position: (48, 15),
                                    },
                                    attribute_path: AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "fetchCargoTarball",
                                                position: (48, 28),
                                            },
                                        ],
                                    },
                                    default: None,
                                },
                                arguments: [
                                    Map {
                                        bindings: [
                                            Inherit(
                                                None,
                                                [
                                                    Raw {
                                                        content: "src",
                                                        position: (49, 13),
                                                    },
                                                ],
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "name",
                                                            position: (50, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "pname",
                                                                position: (50, 15),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "-",
                                                            position: (50, 21),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "version",
                                                                position: (50, 24),
                                                            },
                                                        },
                                                    ],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "sha256",
                                                            position: (51, 5),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "sha256-TmrR8EeySsGWXohMdo3dCX4oT3l9uLVv5TUeRxCBQeE=",
                                                            position: (51, 15),
                                                        },
                                                    ],
                                                },
                                            ),
                                        ],
                                        recursive: false,
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "format",
                                        position: (54, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "pyproject",
                                        position: (54, 13),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "buildAndTestSubdir",
                                        position: (56, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "wheel",
                                        position: (56, 25),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "nativeBuildInputs",
                                        position: (58, 3),
                                    },
                                ],
                            },
                            BinaryOperation {
                                operator: Concatenation,
                                operands: [
                                    List {
                                        elements: [
                                            Variable {
                                                identifier: "perl",
                                                position: (59, 5),
                                            },
                                            Variable {
                                                identifier: "maturin_0_11",
                                                position: (60, 5),
                                            },
                                        ],
                                    },
                                    With {
                                        expression: Variable {
                                            identifier: "rustPlatform",
                                            position: (61, 14),
                                        },
                                        target: List {
                                            elements: [
                                                Variable {
                                                    identifier: "cargoSetupHook",
                                                    position: (62, 5),
                                                },
                                                Variable {
                                                    identifier: "maturinBuildHook",
                                                    position: (63, 5),
                                                },
                                            ],
                                        },
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "buildInputs",
                                        position: (66, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    Variable {
                                        identifier: "openssl",
                                        position: (66, 19),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "pythonImportsCheck",
                                        position: (68, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    String {
                                        parts: [
                                            Raw {
                                                content: "clvm_rs",
                                                position: (68, 27),
                                            },
                                        ],
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "meta",
                                        position: (70, 3),
                                    },
                                ],
                            },
                            With {
                                expression: Variable {
                                    identifier: "lib",
                                    position: (70, 15),
                                },
                                target: Map {
                                    bindings: [
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "homepage",
                                                        position: (71, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "https://chialisp.com/",
                                                        position: (71, 17),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "description",
                                                        position: (72, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "Rust implementation of clvm",
                                                        position: (72, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "license",
                                                        position: (73, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "licenses",
                                                    position: (73, 15),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "asl20",
                                                            position: (73, 24),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "maintainers",
                                                        position: (74, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "teams",
                                                    position: (74, 19),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "chia",
                                                            position: (74, 25),
                                                        },
                                                        Raw {
                                                            content: "members",
                                                            position: (74, 30),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                    ],
                                    recursive: false,
                                },
                            },
                        ),
                    ],
                    recursive: true,
                },
            ],
        },
    },
}