---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: Map {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "toTargetArch",
                            position: (5, 3),
                        },
                    ],
                },
                Function {
                    argument: Some(
                        "platform",
                    ),
                    arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                    },
                    definition: IfThenElse {
                        predicate: PropertyAccess {
                            expression: Variable {
                                identifier: "platform",
                                position: (6, 8),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "isAarch32",
                                        position: (6, 17),
                                    },
                                ],
                            },
                            default: None,
                        },
                        then: String {
                            parts: [
                                Raw {
                                    content: "arm",
                                    position: (6, 33),
                                },
                            ],
                        },
                        else_: PropertyAccess {
                            expression: Variable {
                                identifier: "platform",
                                position: (7, 10),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "parsed",
                                        position: (7, 19),
                                    },
                                    Raw {
                                        content: "cpu",
                                        position: (7, 26),
                                    },
                                    Raw {
                                        content: "name",
                                        position: (7, 30),
                                    },
                                ],
                            },
                            default: None,
                        },
                    },
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "toTargetOs",
                            position: (10, 3),
                        },
                    ],
                },
                Function {
                    argument: Some(
                        "platform",
                    ),
                    arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                    },
                    definition: IfThenElse {
                        predicate: PropertyAccess {
                            expression: Variable {
                                identifier: "platform",
                                position: (11, 8),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "isDarwin",
                                        position: (11, 17),
                                    },
                                ],
                            },
                            default: None,
                        },
                        then: String {
                            parts: [
                                Raw {
                                    content: "macos",
                                    position: (11, 32),
                                },
                            ],
                        },
                        else_: PropertyAccess {
                            expression: Variable {
                                identifier: "platform",
                                position: (12, 10),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "parsed",
                                        position: (12, 19),
                                    },
                                    Raw {
                                        content: "kernel",
                                        position: (12, 26),
                                    },
                                    Raw {
                                        content: "name",
                                        position: (12, 33),
                                    },
                                ],
                            },
                            default: None,
                        },
                    },
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "toRustTarget",
                            position: (16, 3),
                        },
                    ],
                },
                Function {
                    argument: Some(
                        "platform",
                    ),
                    arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                    },
                    definition: LetIn {
                        bindings: [
                            Inherit(
                                Some(
                                    PropertyAccess {
                                        expression: Variable {
                                            identifier: "platform",
                                            position: (17, 14),
                                        },
                                        attribute_path: AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "parsed",
                                                    position: (17, 23),
                                                },
                                            ],
                                        },
                                        default: None,
                                    },
                                ),
                                [
                                    Raw {
                                        content: "cpu",
                                        position: (17, 31),
                                    },
                                    Raw {
                                        content: "vendor",
                                        position: (17, 35),
                                    },
                                    Raw {
                                        content: "kernel",
                                        position: (17, 42),
                                    },
                                    Raw {
                                        content: "abi",
                                        position: (17, 49),
                                    },
                                ],
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "cpu_",
                                            position: (18, 5),
                                        },
                                    ],
                                },
                                PropertyAccess {
                                    expression: Variable {
                                        identifier: "platform",
                                        position: (18, 12),
                                    },
                                    attribute_path: AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "rustc",
                                                position: (18, 21),
                                            },
                                            Raw {
                                                content: "platform",
                                                position: (18, 27),
                                            },
                                            Raw {
                                                content: "arch",
                                                position: (18, 36),
                                            },
                                        ],
                                    },
                                    default: Some(
                                        PropertyAccess {
                                            expression: Map {
                                                bindings: [
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Expression {
                                                                    expression: String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "armv7a",
                                                                                position: (19, 8),
                                                                            },
                                                                        ],
                                                                    },
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "armv7",
                                                                    position: (19, 19),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Expression {
                                                                    expression: String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "armv7l",
                                                                                position: (20, 8),
                                                                            },
                                                                        ],
                                                                    },
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "armv7",
                                                                    position: (20, 19),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Expression {
                                                                    expression: String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "armv6l",
                                                                                position: (21, 8),
                                                                            },
                                                                        ],
                                                                    },
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "arm",
                                                                    position: (21, 19),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Expression {
                                                                    expression: String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "armv5tel",
                                                                                position: (22, 8),
                                                                            },
                                                                        ],
                                                                    },
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "armv5te",
                                                                    position: (22, 21),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Expression {
                                                                    expression: String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "riscv64",
                                                                                position: (23, 8),
                                                                            },
                                                                        ],
                                                                    },
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "riscv64gc",
                                                                    position: (23, 20),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                recursive: false,
                                            },
                                            attribute_path: AttributePath {
                                                attributes: [
                                                    Expression {
                                                        expression: PropertyAccess {
                                                            expression: Variable {
                                                                identifier: "cpu",
                                                                position: (24, 9),
                                                            },
                                                            attribute_path: AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "name",
                                                                        position: (24, 13),
                                                                    },
                                                                ],
                                                            },
                                                            default: None,
                                                        },
                                                    },
                                                ],
                                            },
                                            default: Some(
                                                PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "cpu",
                                                        position: (24, 22),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "name",
                                                                position: (24, 26),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "vendor_",
                                            position: (25, 5),
                                        },
                                    ],
                                },
                                PropertyAccess {
                                    expression: Variable {
                                        identifier: "platform",
                                        position: (25, 15),
                                    },
                                    attribute_path: AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "rustc",
                                                position: (25, 24),
                                            },
                                            Raw {
                                                content: "platform",
                                                position: (25, 30),
                                            },
                                            Raw {
                                                content: "vendor",
                                                position: (25, 39),
                                            },
                                        ],
                                    },
                                    default: Some(
                                        PropertyAccess {
                                            expression: Map {
                                                bindings: [
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Expression {
                                                                    expression: String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "w64",
                                                                                position: (26, 8),
                                                                            },
                                                                        ],
                                                                    },
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "pc",
                                                                    position: (26, 16),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                recursive: false,
                                            },
                                            attribute_path: AttributePath {
                                                attributes: [
                                                    Expression {
                                                        expression: PropertyAccess {
                                                            expression: Variable {
                                                                identifier: "vendor",
                                                                position: (27, 9),
                                                            },
                                                            attribute_path: AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "name",
                                                                        position: (27, 16),
                                                                    },
                                                                ],
                                                            },
                                                            default: None,
                                                        },
                                                    },
                                                ],
                                            },
                                            default: Some(
                                                PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "vendor",
                                                        position: (27, 25),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "name",
                                                                position: (27, 32),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                            ),
                                        },
                                    ),
                                },
                            ),
                        ],
                        target: PropertyAccess {
                            expression: Variable {
                                identifier: "platform",
                                position: (28, 6),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "rustc",
                                        position: (28, 15),
                                    },
                                    Raw {
                                        content: "config",
                                        position: (28, 21),
                                    },
                                ],
                            },
                            default: Some(
                                String {
                                    parts: [
                                        Expression {
                                            expression: Variable {
                                                identifier: "cpu_",
                                                position: (29, 11),
                                            },
                                        },
                                        Raw {
                                            content: "-",
                                            position: (29, 16),
                                        },
                                        Expression {
                                            expression: Variable {
                                                identifier: "vendor_",
                                                position: (29, 19),
                                            },
                                        },
                                        Raw {
                                            content: "-",
                                            position: (29, 27),
                                        },
                                        Expression {
                                            expression: PropertyAccess {
                                                expression: Variable {
                                                    identifier: "kernel",
                                                    position: (29, 30),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "name",
                                                            position: (29, 37),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (29, 44),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionalString",
                                                                position: (29, 48),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    BinaryOperation {
                                                        operator: NotEqualTo,
                                                        operands: [
                                                            PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "abi",
                                                                    position: (29, 64),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "name",
                                                                            position: (29, 68),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "unknown",
                                                                        position: (29, 77),
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "-",
                                                                position: (29, 88),
                                                            },
                                                            Expression {
                                                                expression: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "abi",
                                                                        position: (29, 91),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "name",
                                                                                position: (29, 95),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                    ],
                                },
                            ),
                        },
                    },
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "toRustTargetSpec",
                            position: (33, 3),
                        },
                    ],
                },
                Function {
                    argument: Some(
                        "platform",
                    ),
                    arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                    },
                    definition: IfThenElse {
                        predicate: BinaryOperation {
                            operator: HasAttribute,
                            operands: [
                                PropertyAccess {
                                    expression: Variable {
                                        identifier: "platform",
                                        position: (34, 9),
                                    },
                                    attribute_path: AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "rustc",
                                                position: (34, 18),
                                            },
                                        ],
                                    },
                                    default: Some(
                                        Map {
                                            bindings: [],
                                            recursive: false,
                                        },
                                    ),
                                },
                                __AttributePath(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "platform",
                                                position: (34, 33),
                                            },
                                        ],
                                    },
                                ),
                            ],
                        },
                        then: FunctionApplication {
                            function: PropertyAccess {
                                expression: Variable {
                                    identifier: "builtins",
                                    position: (35, 10),
                                },
                                attribute_path: AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "toFile",
                                            position: (35, 19),
                                        },
                                    ],
                                },
                                default: None,
                            },
                            arguments: [
                                BinaryOperation {
                                    operator: Addition,
                                    operands: [
                                        FunctionApplication {
                                            function: Variable {
                                                identifier: "toRustTarget",
                                                position: (35, 27),
                                            },
                                            arguments: [
                                                Variable {
                                                    identifier: "platform",
                                                    position: (35, 40),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: ".json",
                                                    position: (35, 52),
                                                },
                                            ],
                                        },
                                    ],
                                },
                                FunctionApplication {
                                    function: PropertyAccess {
                                        expression: Variable {
                                            identifier: "builtins",
                                            position: (35, 61),
                                        },
                                        attribute_path: AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "toJSON",
                                                    position: (35, 70),
                                                },
                                            ],
                                        },
                                        default: None,
                                    },
                                    arguments: [
                                        PropertyAccess {
                                            expression: Variable {
                                                identifier: "platform",
                                                position: (35, 77),
                                            },
                                            attribute_path: AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "rustc",
                                                        position: (35, 86),
                                                    },
                                                    Raw {
                                                        content: "platform",
                                                        position: (35, 92),
                                                    },
                                                ],
                                            },
                                            default: None,
                                        },
                                    ],
                                },
                            ],
                        },
                        else_: FunctionApplication {
                            function: Variable {
                                identifier: "toRustTarget",
                                position: (36, 10),
                            },
                            arguments: [
                                Variable {
                                    identifier: "platform",
                                    position: (36, 23),
                                },
                            ],
                        },
                    },
                },
            ),
        ],
        recursive: true,
    },
}