---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "jdk17",
                default: None,
            },
            FunctionArgument {
                identifier: "jdk11",
                default: None,
            },
            FunctionArgument {
                identifier: "jdk8",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: Map {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "gen",
                            position: (4, 3),
                        },
                    ],
                },
                Function {
                    argument: None,
                    arguments: FunctionArguments {
                        arguments: [
                            FunctionArgument {
                                identifier: "supportedPlatforms",
                                default: Some(
                                    Variable {
                                        identifier: "null",
                                        position: (6, 80),
                                    },
                                ),
                            },
                            FunctionArgument {
                                identifier: "defaultJava",
                                default: Some(
                                    Variable {
                                        identifier: "jdk8",
                                        position: (6, 53),
                                    },
                                ),
                            },
                            FunctionArgument {
                                identifier: "sha256",
                                default: None,
                            },
                            FunctionArgument {
                                identifier: "nativeVersion",
                                default: None,
                            },
                            FunctionArgument {
                                identifier: "version",
                                default: None,
                            },
                        ],
                        ellipsis: false,
                    },
                    definition: Function {
                        argument: None,
                        arguments: FunctionArguments {
                            arguments: [
                                FunctionArgument {
                                    identifier: "ncurses6",
                                    default: None,
                                },
                                FunctionArgument {
                                    identifier: "ncurses5",
                                    default: None,
                                },
                                FunctionArgument {
                                    identifier: "javaToolchains",
                                    default: Some(
                                        List {
                                            elements: [],
                                        },
                                    ),
                                },
                                FunctionArgument {
                                    identifier: "java",
                                    default: Some(
                                        Variable {
                                            identifier: "defaultJava",
                                            position: (8, 57),
                                        },
                                    ),
                                },
                                FunctionArgument {
                                    identifier: "unzip",
                                    default: None,
                                },
                                FunctionArgument {
                                    identifier: "makeWrapper",
                                    default: None,
                                },
                                FunctionArgument {
                                    identifier: "fetchurl",
                                    default: None,
                                },
                                FunctionArgument {
                                    identifier: "stdenv",
                                    default: None,
                                },
                                FunctionArgument {
                                    identifier: "lib",
                                    default: None,
                                },
                            ],
                            ellipsis: false,
                        },
                        definition: FunctionApplication {
                            function: PropertyAccess {
                                expression: Variable {
                                    identifier: "stdenv",
                                    position: (11, 5),
                                },
                                attribute_path: AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "mkDerivation",
                                            position: (11, 12),
                                        },
                                    ],
                                },
                                default: None,
                            },
                            arguments: [
                                Map {
                                    bindings: [
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "pname",
                                                        position: (12, 7),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "gradle",
                                                        position: (12, 16),
                                                    },
                                                ],
                                            },
                                        ),
                                        Inherit(
                                            None,
                                            [
                                                Raw {
                                                    content: "version",
                                                    position: (13, 15),
                                                },
                                            ],
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "src",
                                                        position: (15, 7),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: Variable {
                                                    identifier: "fetchurl",
                                                    position: (15, 13),
                                                },
                                                arguments: [
                                                    Map {
                                                        bindings: [
                                                            Inherit(
                                                                None,
                                                                [
                                                                    Raw {
                                                                        content: "sha256",
                                                                        position: (16, 17),
                                                                    },
                                                                ],
                                                            ),
                                                            KeyValue(
                                                                AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "url",
                                                                            position: (17, 9),
                                                                        },
                                                                    ],
                                                                },
                                                                String {
                                                                    parts: [
                                                                        Raw {
                                                                            content: "https://services.gradle.org/distributions/gradle-",
                                                                            position: (18, 12),
                                                                        },
                                                                        Expression {
                                                                            expression: Variable {
                                                                                identifier: "version",
                                                                                position: (18, 63),
                                                                            },
                                                                        },
                                                                        Raw {
                                                                            content: "-bin.zip",
                                                                            position: (18, 71),
                                                                        },
                                                                    ],
                                                                },
                                                            ),
                                                        ],
                                                        recursive: false,
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "dontBuild",
                                                        position: (21, 7),
                                                    },
                                                ],
                                            },
                                            Variable {
                                                identifier: "true",
                                                position: (21, 19),
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "nativeBuildInputs",
                                                        position: (23, 7),
                                                    },
                                                ],
                                            },
                                            List {
                                                elements: [
                                                    Variable {
                                                        identifier: "makeWrapper",
                                                        position: (23, 29),
                                                    },
                                                    Variable {
                                                        identifier: "unzip",
                                                        position: (23, 41),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "buildInputs",
                                                        position: (24, 7),
                                                    },
                                                ],
                                            },
                                            List {
                                                elements: [
                                                    Variable {
                                                        identifier: "java",
                                                        position: (24, 23),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "installPhase",
                                                        position: (28, 7),
                                                    },
                                                ],
                                            },
                                            With {
                                                expression: Variable {
                                                    identifier: "builtins",
                                                    position: (28, 27),
                                                },
                                                target: LetIn {
                                                    bindings: [
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "toolchain",
                                                                        position: (30, 11),
                                                                    },
                                                                ],
                                                            },
                                                            Map {
                                                                bindings: [
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "var",
                                                                                    position: (31, 13),
                                                                                },
                                                                            ],
                                                                        },
                                                                        Function {
                                                                            argument: Some(
                                                                                "x",
                                                                            ),
                                                                            arguments: FunctionArguments {
                                                                                arguments: [],
                                                                                ellipsis: false,
                                                                            },
                                                                            definition: String {
                                                                                parts: [
                                                                                    Raw {
                                                                                        content: "JAVA_TOOLCHAIN_NIX_",
                                                                                        position: (31, 23),
                                                                                    },
                                                                                    Expression {
                                                                                        expression: FunctionApplication {
                                                                                            function: Variable {
                                                                                                identifier: "toString",
                                                                                                position: (31, 44),
                                                                                            },
                                                                                            arguments: [
                                                                                                Variable {
                                                                                                    identifier: "x",
                                                                                                    position: (31, 53),
                                                                                                },
                                                                                            ],
                                                                                        },
                                                                                    },
                                                                                ],
                                                                            },
                                                                        },
                                                                    ),
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "vars",
                                                                                    position: (32, 13),
                                                                                },
                                                                            ],
                                                                        },
                                                                        FunctionApplication {
                                                                            function: PropertyAccess {
                                                                                expression: Variable {
                                                                                    identifier: "lib",
                                                                                    position: (32, 21),
                                                                                },
                                                                                attribute_path: AttributePath {
                                                                                    attributes: [
                                                                                        Raw {
                                                                                            content: "imap0",
                                                                                            position: (32, 25),
                                                                                        },
                                                                                    ],
                                                                                },
                                                                                default: None,
                                                                            },
                                                                            arguments: [
                                                                                Function {
                                                                                    argument: Some(
                                                                                        "i",
                                                                                    ),
                                                                                    arguments: FunctionArguments {
                                                                                        arguments: [],
                                                                                        ellipsis: false,
                                                                                    },
                                                                                    definition: Function {
                                                                                        argument: Some(
                                                                                            "x",
                                                                                        ),
                                                                                        arguments: FunctionArguments {
                                                                                            arguments: [],
                                                                                            ellipsis: false,
                                                                                        },
                                                                                        definition: String {
                                                                                            parts: [
                                                                                                Expression {
                                                                                                    expression: FunctionApplication {
                                                                                                        function: Variable {
                                                                                                            identifier: "var",
                                                                                                            position: (32, 42),
                                                                                                        },
                                                                                                        arguments: [
                                                                                                            Variable {
                                                                                                                identifier: "i",
                                                                                                                position: (32, 46),
                                                                                                            },
                                                                                                        ],
                                                                                                    },
                                                                                                },
                                                                                                Raw {
                                                                                                    content: " ",
                                                                                                    position: (32, 48),
                                                                                                },
                                                                                                Expression {
                                                                                                    expression: Variable {
                                                                                                        identifier: "x",
                                                                                                        position: (32, 51),
                                                                                                    },
                                                                                                },
                                                                                            ],
                                                                                        },
                                                                                    },
                                                                                },
                                                                                Variable {
                                                                                    identifier: "javaToolchains",
                                                                                    position: (32, 57),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "varNames",
                                                                                    position: (33, 13),
                                                                                },
                                                                            ],
                                                                        },
                                                                        FunctionApplication {
                                                                            function: PropertyAccess {
                                                                                expression: Variable {
                                                                                    identifier: "lib",
                                                                                    position: (33, 24),
                                                                                },
                                                                                attribute_path: AttributePath {
                                                                                    attributes: [
                                                                                        Raw {
                                                                                            content: "imap0",
                                                                                            position: (33, 28),
                                                                                        },
                                                                                    ],
                                                                                },
                                                                                default: None,
                                                                            },
                                                                            arguments: [
                                                                                Function {
                                                                                    argument: Some(
                                                                                        "i",
                                                                                    ),
                                                                                    arguments: FunctionArguments {
                                                                                        arguments: [],
                                                                                        ellipsis: false,
                                                                                    },
                                                                                    definition: Function {
                                                                                        argument: Some(
                                                                                            "x",
                                                                                        ),
                                                                                        arguments: FunctionArguments {
                                                                                            arguments: [],
                                                                                            ellipsis: false,
                                                                                        },
                                                                                        definition: FunctionApplication {
                                                                                            function: Variable {
                                                                                                identifier: "var",
                                                                                                position: (33, 41),
                                                                                            },
                                                                                            arguments: [
                                                                                                Variable {
                                                                                                    identifier: "i",
                                                                                                    position: (33, 45),
                                                                                                },
                                                                                            ],
                                                                                        },
                                                                                    },
                                                                                },
                                                                                Variable {
                                                                                    identifier: "javaToolchains",
                                                                                    position: (33, 48),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "property",
                                                                                    position: (34, 13),
                                                                                },
                                                                            ],
                                                                        },
                                                                        String {
                                                                            parts: [
                                                                                Raw {
                                                                                    content: " -Porg.gradle.java.installations.fromEnv='",
                                                                                    position: (34, 25),
                                                                                },
                                                                                Expression {
                                                                                    expression: FunctionApplication {
                                                                                        function: Variable {
                                                                                            identifier: "concatStringsSep",
                                                                                            position: (35, 18),
                                                                                        },
                                                                                        arguments: [
                                                                                            String {
                                                                                                parts: [
                                                                                                    Raw {
                                                                                                        content: ",",
                                                                                                        position: (35, 36),
                                                                                                    },
                                                                                                ],
                                                                                            },
                                                                                            Variable {
                                                                                                identifier: "varNames",
                                                                                                position: (35, 39),
                                                                                            },
                                                                                        ],
                                                                                    },
                                                                                },
                                                                                Raw {
                                                                                    content: "'",
                                                                                    position: (36, 17),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                ],
                                                                recursive: true,
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "vars",
                                                                        position: (38, 11),
                                                                    },
                                                                ],
                                                            },
                                                            FunctionApplication {
                                                                function: Variable {
                                                                    identifier: "concatStringsSep",
                                                                    position: (38, 18),
                                                                },
                                                                arguments: [
                                                                    String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "\n",
                                                                                position: (38, 36),
                                                                            },
                                                                        ],
                                                                    },
                                                                    FunctionApplication {
                                                                        function: Variable {
                                                                            identifier: "map",
                                                                            position: (38, 41),
                                                                        },
                                                                        arguments: [
                                                                            Function {
                                                                                argument: Some(
                                                                                    "x",
                                                                                ),
                                                                                arguments: FunctionArguments {
                                                                                    arguments: [],
                                                                                    ellipsis: false,
                                                                                },
                                                                                definition: String {
                                                                                    parts: [
                                                                                        Raw {
                                                                                            content: "  --set ",
                                                                                            position: (38, 50),
                                                                                        },
                                                                                        Expression {
                                                                                            expression: Variable {
                                                                                                identifier: "x",
                                                                                                position: (38, 60),
                                                                                            },
                                                                                        },
                                                                                        Raw {
                                                                                            content: " \\",
                                                                                            position: (38, 62),
                                                                                        },
                                                                                    ],
                                                                                },
                                                                            },
                                                                            BinaryOperation {
                                                                                operator: Concatenation,
                                                                                operands: [
                                                                                    List {
                                                                                        elements: [
                                                                                            String {
                                                                                                parts: [
                                                                                                    Raw {
                                                                                                        content: "JAVA_HOME ",
                                                                                                        position: (39, 17),
                                                                                                    },
                                                                                                    Expression {
                                                                                                        expression: Variable {
                                                                                                            identifier: "java",
                                                                                                            position: (39, 29),
                                                                                                        },
                                                                                                    },
                                                                                                ],
                                                                                            },
                                                                                        ],
                                                                                    },
                                                                                    PropertyAccess {
                                                                                        expression: Variable {
                                                                                            identifier: "toolchain",
                                                                                            position: (39, 41),
                                                                                        },
                                                                                        attribute_path: AttributePath {
                                                                                            attributes: [
                                                                                                Raw {
                                                                                                    content: "vars",
                                                                                                    position: (39, 51),
                                                                                                },
                                                                                            ],
                                                                                        },
                                                                                        default: None,
                                                                                    },
                                                                                ],
                                                                            },
                                                                        ],
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                    ],
                                                    target: String {
                                                        parts: [
                                                            Raw {
                                                                content: "mkdir -pv $out/lib/gradle/\ncp -rv lib/ $out/lib/gradle/\n\ngradle_launcher_jar=$(echo $out/lib/gradle/lib/gradle-launcher-*.jar)\ntest -f $gradle_launcher_jar\nmakeWrapper ",
                                                                position: (41, 1),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "java",
                                                                    position: (46, 25),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/java $out/bin/gradle \\\n  ",
                                                                position: (46, 30),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "vars",
                                                                    position: (47, 15),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "\n  --add-flags \"-classpath $gradle_launcher_jar org.gradle.launcher.GradleMain",
                                                                position: (47, 20),
                                                            },
                                                            Expression {
                                                                expression: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "toolchain",
                                                                        position: (48, 90),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "property",
                                                                                position: (48, 100),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                            },
                                                            Raw {
                                                                content: "\"\n",
                                                                position: (48, 109),
                                                            },
                                                        ],
                                                    },
                                                },
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "dontFixup",
                                                        position: (51, 7),
                                                    },
                                                ],
                                            },
                                            UnaryOperation {
                                                operator: Not,
                                                operand: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "stdenv",
                                                        position: (51, 20),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "isLinux",
                                                                position: (51, 27),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "fixupPhase",
                                                        position: (53, 7),
                                                    },
                                                ],
                                            },
                                            LetIn {
                                                bindings: [
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "arch",
                                                                    position: (53, 24),
                                                                },
                                                            ],
                                                        },
                                                        IfThenElse {
                                                            predicate: PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "stdenv",
                                                                    position: (53, 34),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "is64bit",
                                                                            position: (53, 41),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                            then: String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "amd64",
                                                                        position: (53, 55),
                                                                    },
                                                                ],
                                                            },
                                                            else_: String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "i386",
                                                                        position: (53, 68),
                                                                    },
                                                                ],
                                                            },
                                                        },
                                                    ),
                                                ],
                                                target: String {
                                                    parts: [
                                                        Raw {
                                                            content: "for variant in \"\" \"-ncurses5\" \"-ncurses6\"; do\n  mkdir \"patching$variant\"\n  pushd \"patching$variant\"\n  jar xf $out/lib/gradle/lib/native-platform-linux-",
                                                            position: (55, 1),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "arch",
                                                                position: (58, 62),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "$variant-",
                                                            position: (58, 67),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "nativeVersion",
                                                                position: (58, 78),
                                                            },
                                                        },
                                                        Raw {
                                                            content: ".jar\n  patchelf \\\n    --set-rpath \"",
                                                            position: (58, 92),
                                                        },
                                                        Expression {
                                                            expression: PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "stdenv",
                                                                    position: (60, 28),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "cc",
                                                                            position: (60, 35),
                                                                        },
                                                                        Raw {
                                                                            content: "cc",
                                                                            position: (60, 38),
                                                                        },
                                                                        Raw {
                                                                            content: "lib",
                                                                            position: (60, 41),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                        },
                                                        Raw {
                                                            content: "/lib64:",
                                                            position: (60, 45),
                                                        },
                                                        Expression {
                                                            expression: FunctionApplication {
                                                                function: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "lib",
                                                                        position: (60, 54),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "makeLibraryPath",
                                                                                position: (60, 58),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                                arguments: [
                                                                    List {
                                                                        elements: [
                                                                            PropertyAccess {
                                                                                expression: Variable {
                                                                                    identifier: "stdenv",
                                                                                    position: (60, 76),
                                                                                },
                                                                                attribute_path: AttributePath {
                                                                                    attributes: [
                                                                                        Raw {
                                                                                            content: "cc",
                                                                                            position: (60, 83),
                                                                                        },
                                                                                        Raw {
                                                                                            content: "cc",
                                                                                            position: (60, 86),
                                                                                        },
                                                                                    ],
                                                                                },
                                                                                default: None,
                                                                            },
                                                                            Variable {
                                                                                identifier: "ncurses5",
                                                                                position: (60, 89),
                                                                            },
                                                                            Variable {
                                                                                identifier: "ncurses6",
                                                                                position: (60, 98),
                                                                            },
                                                                        ],
                                                                    },
                                                                ],
                                                            },
                                                        },
                                                        Raw {
                                                            content: "\" \\\n    net/rubygrapefruit/platform/linux-",
                                                            position: (60, 109),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "arch",
                                                                position: (61, 49),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "$variant/libnative-platform*.so\n  jar cf native-platform-linux-",
                                                            position: (61, 54),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "arch",
                                                                position: (62, 42),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "$variant-",
                                                            position: (62, 47),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "nativeVersion",
                                                                position: (62, 58),
                                                            },
                                                        },
                                                        Raw {
                                                            content: ".jar .\n  mv native-platform-linux-",
                                                            position: (62, 72),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "arch",
                                                                position: (63, 38),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "$variant-",
                                                            position: (63, 43),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "nativeVersion",
                                                                position: (63, 54),
                                                            },
                                                        },
                                                        Raw {
                                                            content: ".jar $out/lib/gradle/lib/\n  popd\ndone\n\n# The scanner doesn't pick up the runtime dependency in the jar.\n# Manually add a reference where it will be found.\nmkdir $out/nix-support\necho ",
                                                            position: (63, 68),
                                                        },
                                                        Expression {
                                                            expression: PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "stdenv",
                                                                    position: (70, 16),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "cc",
                                                                            position: (70, 23),
                                                                        },
                                                                        Raw {
                                                                            content: "cc",
                                                                            position: (70, 26),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                        },
                                                        Raw {
                                                            content: " > $out/nix-support/manual-runtime-dependencies\n# Gradle will refuse to start without _both_ 5 and 6 versions of ncurses.\necho ",
                                                            position: (70, 29),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "ncurses5",
                                                                position: (72, 16),
                                                            },
                                                        },
                                                        Raw {
                                                            content: " >> $out/nix-support/manual-runtime-dependencies\necho ",
                                                            position: (72, 25),
                                                        },
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "ncurses6",
                                                                position: (73, 16),
                                                            },
                                                        },
                                                        Raw {
                                                            content: " >> $out/nix-support/manual-runtime-dependencies\n",
                                                            position: (73, 25),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "meta",
                                                        position: (76, 7),
                                                    },
                                                ],
                                            },
                                            With {
                                                expression: Variable {
                                                    identifier: "lib",
                                                    position: (76, 19),
                                                },
                                                target: Map {
                                                    bindings: [
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "description",
                                                                        position: (77, 9),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "Enterprise-grade build system",
                                                                        position: (77, 24),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "longDescription",
                                                                        position: (78, 9),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "Gradle is a build system which offers you ease, power and freedom.\nYou can choose the balance for yourself. It has powerful multi-project\nbuild support. It has a layer on top of Ivy that provides a\nbuild-by-convention integration for Ivy. It gives you always the choice\nbetween the flexibility of Ant and the convenience of a\nbuild-by-convention behavior.\n",
                                                                        position: (79, 1),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "homepage",
                                                                        position: (86, 9),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "https://www.gradle.org/",
                                                                        position: (86, 21),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "changelog",
                                                                        position: (87, 9),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "https://docs.gradle.org/",
                                                                        position: (87, 22),
                                                                    },
                                                                    Expression {
                                                                        expression: Variable {
                                                                            identifier: "version",
                                                                            position: (87, 48),
                                                                        },
                                                                    },
                                                                    Raw {
                                                                        content: "/release-notes.html",
                                                                        position: (87, 56),
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "downloadPage",
                                                                        position: (88, 9),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "https://gradle.org/next-steps/?version=",
                                                                        position: (88, 25),
                                                                    },
                                                                    Expression {
                                                                        expression: Variable {
                                                                            identifier: "version",
                                                                            position: (88, 66),
                                                                        },
                                                                    },
                                                                ],
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "license",
                                                                        position: (89, 9),
                                                                    },
                                                                ],
                                                            },
                                                            PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "licenses",
                                                                    position: (89, 19),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "asl20",
                                                                            position: (89, 28),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "platforms",
                                                                        position: (90, 9),
                                                                    },
                                                                ],
                                                            },
                                                            IfThenElse {
                                                                predicate: BinaryOperation {
                                                                    operator: NotEqualTo,
                                                                    operands: [
                                                                        Variable {
                                                                            identifier: "supportedPlatforms",
                                                                            position: (90, 25),
                                                                        },
                                                                        Variable {
                                                                            identifier: "null",
                                                                            position: (90, 47),
                                                                        },
                                                                    ],
                                                                },
                                                                then: Variable {
                                                                    identifier: "supportedPlatforms",
                                                                    position: (90, 58),
                                                                },
                                                                else_: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "platforms",
                                                                        position: (90, 82),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "unix",
                                                                                position: (90, 92),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                            },
                                                        ),
                                                        KeyValue(
                                                            AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "maintainers",
                                                                        position: (91, 9),
                                                                    },
                                                                ],
                                                            },
                                                            With {
                                                                expression: Variable {
                                                                    identifier: "maintainers",
                                                                    position: (91, 28),
                                                                },
                                                                target: List {
                                                                    elements: [
                                                                        Variable {
                                                                            identifier: "lorenzleutgeb",
                                                                            position: (91, 43),
                                                                        },
                                                                        Variable {
                                                                            identifier: "liff",
                                                                            position: (91, 57),
                                                                        },
                                                                    ],
                                                                },
                                                            },
                                                        ),
                                                    ],
                                                    recursive: false,
                                                },
                                            },
                                        ),
                                    ],
                                    recursive: true,
                                },
                            ],
                        },
                    },
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "gradle_7",
                            position: (98, 3),
                        },
                    ],
                },
                FunctionApplication {
                    function: Variable {
                        identifier: "gen",
                        position: (98, 14),
                    },
                    arguments: [
                        Map {
                            bindings: [
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "version",
                                                position: (99, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "7.4.2",
                                                position: (99, 16),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "nativeVersion",
                                                position: (100, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "0.22-milestone-23",
                                                position: (100, 22),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "sha256",
                                                position: (101, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "1nkz9gn1vb5l94dkf9yzb1j3hkll5x2vrl5p320msn2fk089pr19",
                                                position: (101, 15),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "defaultJava",
                                                position: (102, 5),
                                            },
                                        ],
                                    },
                                    Variable {
                                        identifier: "jdk17",
                                        position: (102, 19),
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "supportedPlatforms",
                                                position: (105, 5),
                                            },
                                        ],
                                    },
                                    List {
                                        elements: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-linux",
                                                        position: (105, 30),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "aarch64-linux",
                                                        position: (105, 45),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "aarch64-darwin",
                                                        position: (105, 61),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-darwin",
                                                        position: (105, 78),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-cygwin",
                                                        position: (105, 94),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-windows",
                                                        position: (105, 110),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "i686-windows",
                                                        position: (105, 127),
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                            ],
                            recursive: false,
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "gradle_6",
                            position: (108, 3),
                        },
                    ],
                },
                FunctionApplication {
                    function: Variable {
                        identifier: "gen",
                        position: (108, 14),
                    },
                    arguments: [
                        Map {
                            bindings: [
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "version",
                                                position: (109, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "6.9.2",
                                                position: (109, 16),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "nativeVersion",
                                                position: (110, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "0.22-milestone-20",
                                                position: (110, 22),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "sha256",
                                                position: (111, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "13qyk3f6namw27ynh6nxljxpk9r3l12vxl3f0qpglprdf3c6ydcb",
                                                position: (111, 15),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "defaultJava",
                                                position: (112, 5),
                                            },
                                        ],
                                    },
                                    Variable {
                                        identifier: "jdk11",
                                        position: (112, 19),
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "supportedPlatforms",
                                                position: (115, 5),
                                            },
                                        ],
                                    },
                                    List {
                                        elements: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-linux",
                                                        position: (115, 30),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "aarch64-linux",
                                                        position: (115, 45),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "aarch64-darwin",
                                                        position: (115, 61),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-darwin",
                                                        position: (115, 78),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-cygwin",
                                                        position: (115, 94),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "x86_64-windows",
                                                        position: (115, 110),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "i686-windows",
                                                        position: (115, 127),
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                            ],
                            recursive: false,
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "gradle_5",
                            position: (119, 3),
                        },
                    ],
                },
                FunctionApplication {
                    function: Variable {
                        identifier: "gen",
                        position: (119, 14),
                    },
                    arguments: [
                        Map {
                            bindings: [
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "version",
                                                position: (120, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "5.6.4",
                                                position: (120, 16),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "nativeVersion",
                                                position: (121, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "0.18",
                                                position: (121, 22),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "sha256",
                                                position: (122, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "03d86bbqd19h9xlanffcjcy3vg1k5905vzhf9mal9g21603nfc0z",
                                                position: (122, 15),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "defaultJava",
                                                position: (123, 5),
                                            },
                                        ],
                                    },
                                    Variable {
                                        identifier: "jdk11",
                                        position: (123, 19),
                                    },
                                ),
                            ],
                            recursive: false,
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "gradle_4",
                            position: (126, 3),
                        },
                    ],
                },
                FunctionApplication {
                    function: Variable {
                        identifier: "gen",
                        position: (126, 14),
                    },
                    arguments: [
                        Map {
                            bindings: [
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "version",
                                                position: (127, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "4.10.3",
                                                position: (127, 16),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "nativeVersion",
                                                position: (128, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "0.14",
                                                position: (128, 22),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "sha256",
                                                position: (129, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "0vhqxnk0yj3q9jam5w4kpia70i4h0q4pjxxqwynh3qml0vrcn9l6",
                                                position: (129, 15),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "defaultJava",
                                                position: (130, 5),
                                            },
                                        ],
                                    },
                                    Variable {
                                        identifier: "jdk8",
                                        position: (130, 19),
                                    },
                                ),
                            ],
                            recursive: false,
                        },
                    ],
                },
            ),
        ],
        recursive: true,
    },
}