---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "GConf",
                default: None,
            },
            FunctionArgument {
                identifier: "glib",
                default: None,
            },
            FunctionArgument {
                identifier: "gnome_vfs",
                default: None,
            },
            FunctionArgument {
                identifier: "gtk3",
                default: None,
            },
            FunctionArgument {
                identifier: "enableGnome2",
                default: Some(
                    Variable {
                        identifier: "true",
                        position: (8, 18),
                    },
                ),
            },
            FunctionArgument {
                identifier: "openjfx",
                default: None,
            },
            FunctionArgument {
                identifier: "enableJavaFX",
                default: Some(
                    PropertyAccess {
                        expression: Variable {
                            identifier: "openjfx",
                            position: (7, 18),
                        },
                        attribute_path: AttributePath {
                            attributes: [
                                Raw {
                                    content: "meta",
                                    position: (7, 26),
                                },
                                Raw {
                                    content: "available",
                                    position: (7, 31),
                                },
                            ],
                        },
                        default: None,
                    },
                ),
            },
            FunctionArgument {
                identifier: "headless",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (6, 14),
                    },
                ),
            },
            FunctionArgument {
                identifier: "setJavaClassPath",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchpatch",
                default: None,
            },
            FunctionArgument {
                identifier: "openjdk11",
                default: None,
            },
            FunctionArgument {
                identifier: "fontconfig",
                default: None,
            },
            FunctionArgument {
                identifier: "libXrandr",
                default: None,
            },
            FunctionArgument {
                identifier: "libXcursor",
                default: None,
            },
            FunctionArgument {
                identifier: "libXinerama",
                default: None,
            },
            FunctionArgument {
                identifier: "libXi",
                default: None,
            },
            FunctionArgument {
                identifier: "libXtst",
                default: None,
            },
            FunctionArgument {
                identifier: "libXt",
                default: None,
            },
            FunctionArgument {
                identifier: "libXext",
                default: None,
            },
            FunctionArgument {
                identifier: "libXrender",
                default: None,
            },
            FunctionArgument {
                identifier: "libICE",
                default: None,
            },
            FunctionArgument {
                identifier: "libX11",
                default: None,
            },
            FunctionArgument {
                identifier: "lcms2",
                default: None,
            },
            FunctionArgument {
                identifier: "zlib",
                default: None,
            },
            FunctionArgument {
                identifier: "libpng",
                default: None,
            },
            FunctionArgument {
                identifier: "giflib",
                default: None,
            },
            FunctionArgument {
                identifier: "libjpeg",
                default: None,
            },
            FunctionArgument {
                identifier: "alsa-lib",
                default: None,
            },
            FunctionArgument {
                identifier: "freetype",
                default: None,
            },
            FunctionArgument {
                identifier: "cups",
                default: None,
            },
            FunctionArgument {
                identifier: "perl",
                default: None,
            },
            FunctionArgument {
                identifier: "zip",
                default: None,
            },
            FunctionArgument {
                identifier: "unzip",
                default: None,
            },
            FunctionArgument {
                identifier: "which",
                default: None,
            },
            FunctionArgument {
                identifier: "file",
                default: None,
            },
            FunctionArgument {
                identifier: "cpio",
                default: None,
            },
            FunctionArgument {
                identifier: "autoconf",
                default: None,
            },
            FunctionArgument {
                identifier: "pkg-config",
                default: None,
            },
            FunctionArgument {
                identifier: "bash",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchurl",
                default: None,
            },
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
            FunctionArgument {
                identifier: "stdenv",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: LetIn {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "major",
                            position: (12, 3),
                        },
                    ],
                },
                String {
                    parts: [
                        Raw {
                            content: "12",
                            position: (12, 12),
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "update",
                            position: (13, 3),
                        },
                    ],
                },
                String {
                    parts: [
                        Raw {
                            content: ".0.2",
                            position: (13, 13),
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "build",
                            position: (14, 3),
                        },
                    ],
                },
                String {
                    parts: [
                        Raw {
                            content: "ga",
                            position: (14, 12),
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "openjdk",
                            position: (16, 3),
                        },
                    ],
                },
                FunctionApplication {
                    function: PropertyAccess {
                        expression: Variable {
                            identifier: "stdenv",
                            position: (16, 13),
                        },
                        attribute_path: AttributePath {
                            attributes: [
                                Raw {
                                    content: "mkDerivation",
                                    position: (16, 20),
                                },
                            ],
                        },
                        default: None,
                    },
                    arguments: [
                        Map {
                            bindings: [
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "pname",
                                                position: (17, 5),
                                            },
                                        ],
                                    },
                                    BinaryOperation {
                                        operator: Addition,
                                        operands: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "openjdk",
                                                        position: (17, 14),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (17, 25),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionalString",
                                                                position: (17, 29),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "headless",
                                                        position: (17, 44),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "-headless",
                                                                position: (17, 54),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "version",
                                                position: (18, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Expression {
                                                expression: Variable {
                                                    identifier: "major",
                                                    position: (18, 18),
                                                },
                                            },
                                            Expression {
                                                expression: Variable {
                                                    identifier: "update",
                                                    position: (18, 26),
                                                },
                                            },
                                            Raw {
                                                content: "-",
                                                position: (18, 33),
                                            },
                                            Expression {
                                                expression: Variable {
                                                    identifier: "build",
                                                    position: (18, 36),
                                                },
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "src",
                                                position: (20, 5),
                                            },
                                        ],
                                    },
                                    FunctionApplication {
                                        function: Variable {
                                            identifier: "fetchurl",
                                            position: (20, 11),
                                        },
                                        arguments: [
                                            Map {
                                                bindings: [
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "url",
                                                                    position: (21, 7),
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "http://hg.openjdk.java.net/jdk-updates/jdk",
                                                                    position: (21, 14),
                                                                },
                                                                Expression {
                                                                    expression: Variable {
                                                                        identifier: "major",
                                                                        position: (21, 58),
                                                                    },
                                                                },
                                                                Raw {
                                                                    content: "u/archive/jdk-",
                                                                    position: (21, 64),
                                                                },
                                                                Expression {
                                                                    expression: Variable {
                                                                        identifier: "version",
                                                                        position: (21, 80),
                                                                    },
                                                                },
                                                                Raw {
                                                                    content: ".tar.gz",
                                                                    position: (21, 88),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                    KeyValue(
                                                        AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "sha256",
                                                                    position: (22, 7),
                                                                },
                                                            ],
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "1ndlxmikyy298z7lqpr1bd0zxq7yx6xidj8y3c8mw9m9fy64h9c7",
                                                                    position: (22, 17),
                                                                },
                                                            ],
                                                        },
                                                    ),
                                                ],
                                                recursive: false,
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "nativeBuildInputs",
                                                position: (25, 5),
                                            },
                                        ],
                                    },
                                    List {
                                        elements: [
                                            Variable {
                                                identifier: "pkg-config",
                                                position: (25, 27),
                                            },
                                            Variable {
                                                identifier: "autoconf",
                                                position: (25, 38),
                                            },
                                            Variable {
                                                identifier: "unzip",
                                                position: (25, 47),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "buildInputs",
                                                position: (26, 5),
                                            },
                                        ],
                                    },
                                    BinaryOperation {
                                        operator: Concatenation,
                                        operands: [
                                            List {
                                                elements: [
                                                    Variable {
                                                        identifier: "cpio",
                                                        position: (27, 7),
                                                    },
                                                    Variable {
                                                        identifier: "file",
                                                        position: (27, 12),
                                                    },
                                                    Variable {
                                                        identifier: "which",
                                                        position: (27, 17),
                                                    },
                                                    Variable {
                                                        identifier: "zip",
                                                        position: (27, 23),
                                                    },
                                                    Variable {
                                                        identifier: "perl",
                                                        position: (27, 27),
                                                    },
                                                    Variable {
                                                        identifier: "zlib",
                                                        position: (27, 32),
                                                    },
                                                    Variable {
                                                        identifier: "cups",
                                                        position: (27, 37),
                                                    },
                                                    Variable {
                                                        identifier: "freetype",
                                                        position: (27, 42),
                                                    },
                                                    Variable {
                                                        identifier: "alsa-lib",
                                                        position: (27, 51),
                                                    },
                                                    Variable {
                                                        identifier: "libjpeg",
                                                        position: (27, 60),
                                                    },
                                                    Variable {
                                                        identifier: "giflib",
                                                        position: (27, 68),
                                                    },
                                                    Variable {
                                                        identifier: "libpng",
                                                        position: (28, 7),
                                                    },
                                                    Variable {
                                                        identifier: "zlib",
                                                        position: (28, 14),
                                                    },
                                                    Variable {
                                                        identifier: "lcms2",
                                                        position: (28, 19),
                                                    },
                                                    Variable {
                                                        identifier: "libX11",
                                                        position: (28, 25),
                                                    },
                                                    Variable {
                                                        identifier: "libICE",
                                                        position: (28, 32),
                                                    },
                                                    Variable {
                                                        identifier: "libXrender",
                                                        position: (28, 39),
                                                    },
                                                    Variable {
                                                        identifier: "libXext",
                                                        position: (28, 50),
                                                    },
                                                    Variable {
                                                        identifier: "libXtst",
                                                        position: (28, 58),
                                                    },
                                                    Variable {
                                                        identifier: "libXt",
                                                        position: (28, 66),
                                                    },
                                                    Variable {
                                                        identifier: "libXtst",
                                                        position: (28, 72),
                                                    },
                                                    Variable {
                                                        identifier: "libXi",
                                                        position: (29, 7),
                                                    },
                                                    Variable {
                                                        identifier: "libXinerama",
                                                        position: (29, 13),
                                                    },
                                                    Variable {
                                                        identifier: "libXcursor",
                                                        position: (29, 25),
                                                    },
                                                    Variable {
                                                        identifier: "libXrandr",
                                                        position: (29, 36),
                                                    },
                                                    Variable {
                                                        identifier: "fontconfig",
                                                        position: (29, 46),
                                                    },
                                                    Variable {
                                                        identifier: "openjdk11",
                                                        position: (29, 57),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (30, 10),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionals",
                                                                position: (30, 14),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    BinaryOperation {
                                                        operator: LogicalAnd,
                                                        operands: [
                                                            UnaryOperation {
                                                                operator: Not,
                                                                operand: Variable {
                                                                    identifier: "headless",
                                                                    position: (30, 26),
                                                                },
                                                            },
                                                            Variable {
                                                                identifier: "enableGnome2",
                                                                position: (30, 38),
                                                            },
                                                        ],
                                                    },
                                                    List {
                                                        elements: [
                                                            Variable {
                                                                identifier: "gtk3",
                                                                position: (31, 7),
                                                            },
                                                            Variable {
                                                                identifier: "gnome_vfs",
                                                                position: (31, 12),
                                                            },
                                                            Variable {
                                                                identifier: "GConf",
                                                                position: (31, 22),
                                                            },
                                                            Variable {
                                                                identifier: "glib",
                                                                position: (31, 28),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "patches",
                                                position: (34, 5),
                                            },
                                        ],
                                    },
                                    BinaryOperation {
                                        operator: Concatenation,
                                        operands: [
                                            List {
                                                elements: [
                                                    Path {
                                                        parts: [
                                                            Raw {
                                                                content: "./fix-java-home-jdk10.patch",
                                                                position: (35, 7),
                                                            },
                                                        ],
                                                    },
                                                    Path {
                                                        parts: [
                                                            Raw {
                                                                content: "./read-truststore-from-env-jdk10.patch",
                                                                position: (36, 7),
                                                            },
                                                        ],
                                                    },
                                                    Path {
                                                        parts: [
                                                            Raw {
                                                                content: "./currency-date-range-jdk10.patch",
                                                                position: (37, 7),
                                                            },
                                                        ],
                                                    },
                                                    Path {
                                                        parts: [
                                                            Raw {
                                                                content: "./increase-javadoc-heap.patch",
                                                                position: (38, 7),
                                                            },
                                                        ],
                                                    },
                                                    FunctionApplication {
                                                        function: Variable {
                                                            identifier: "fetchurl",
                                                            position: (43, 8),
                                                        },
                                                        arguments: [
                                                            Map {
                                                                bindings: [
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "url",
                                                                                    position: (44, 9),
                                                                                },
                                                                            ],
                                                                        },
                                                                        String {
                                                                            parts: [
                                                                                Raw {
                                                                                    content: "https://src.fedoraproject.org/rpms/java-openjdk/raw/06c001c7d87f2e9fe4fedeef2d993bcd5d7afa2a/f/rh1673833-remove_removal_of_wformat_during_test_compilation.patch",
                                                                                    position: (44, 16),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "sha256",
                                                                                    position: (45, 9),
                                                                                },
                                                                            ],
                                                                        },
                                                                        String {
                                                                            parts: [
                                                                                Raw {
                                                                                    content: "082lmc30x64x583vqq00c8y0wqih3y4r0mp1c4bqq36l22qv6b6r",
                                                                                    position: (45, 19),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                ],
                                                                recursive: false,
                                                            },
                                                        ],
                                                    },
                                                    FunctionApplication {
                                                        function: Variable {
                                                            identifier: "fetchpatch",
                                                            position: (48, 8),
                                                        },
                                                        arguments: [
                                                            Map {
                                                                bindings: [
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "url",
                                                                                    position: (49, 9),
                                                                                },
                                                                            ],
                                                                        },
                                                                        String {
                                                                            parts: [
                                                                                Raw {
                                                                                    content: "https://github.com/openjdk/panama-foreign/commit/af5c725b8109ce83fc04ef0f8bf6aaf0b50c0441.patch",
                                                                                    position: (49, 16),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                    KeyValue(
                                                                        AttributePath {
                                                                            attributes: [
                                                                                Raw {
                                                                                    content: "sha256",
                                                                                    position: (50, 9),
                                                                                },
                                                                            ],
                                                                        },
                                                                        String {
                                                                            parts: [
                                                                                Raw {
                                                                                    content: "0ja84kih5wkjn58pml53s59qnavb1z92dc88cbgw7vcyqwc1gs0h",
                                                                                    position: (50, 19),
                                                                                },
                                                                            ],
                                                                        },
                                                                    ),
                                                                ],
                                                                recursive: false,
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (52, 10),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionals",
                                                                position: (52, 14),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    BinaryOperation {
                                                        operator: LogicalAnd,
                                                        operands: [
                                                            UnaryOperation {
                                                                operator: Not,
                                                                operand: Variable {
                                                                    identifier: "headless",
                                                                    position: (52, 26),
                                                                },
                                                            },
                                                            Variable {
                                                                identifier: "enableGnome2",
                                                                position: (52, 38),
                                                            },
                                                        ],
                                                    },
                                                    List {
                                                        elements: [
                                                            Path {
                                                                parts: [
                                                                    Raw {
                                                                        content: "./swing-use-gtk-jdk10.patch",
                                                                        position: (53, 7),
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "prePatch",
                                                position: (56, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "chmod +x configure\npatchShebangs --build configure\n",
                                                position: (57, 1),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "configureFlags",
                                                position: (61, 5),
                                            },
                                        ],
                                    },
                                    BinaryOperation {
                                        operator: Concatenation,
                                        operands: [
                                            List {
                                                elements: [
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-boot-jdk=",
                                                                position: (62, 8),
                                                            },
                                                            Expression {
                                                                expression: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "openjdk11",
                                                                        position: (62, 26),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "home",
                                                                                position: (62, 36),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-version-pre=",
                                                                position: (63, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--enable-unlimited-crypto",
                                                                position: (64, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-native-debug-symbols=internal",
                                                                position: (65, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-libjpeg=system",
                                                                position: (66, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-giflib=system",
                                                                position: (67, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-libpng=system",
                                                                position: (68, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-zlib=system",
                                                                position: (69, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-lcms=system",
                                                                position: (70, 8),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "--with-stdc++lib=dynamic",
                                                                position: (71, 8),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                            BinaryOperation {
                                                operator: Concatenation,
                                                operands: [
                                                    FunctionApplication {
                                                        function: PropertyAccess {
                                                            expression: Variable {
                                                                identifier: "lib",
                                                                position: (72, 10),
                                                            },
                                                            attribute_path: AttributePath {
                                                                attributes: [
                                                                    Raw {
                                                                        content: "optional",
                                                                        position: (72, 14),
                                                                    },
                                                                ],
                                                            },
                                                            default: None,
                                                        },
                                                        arguments: [
                                                            PropertyAccess {
                                                                expression: Variable {
                                                                    identifier: "stdenv",
                                                                    position: (72, 23),
                                                                },
                                                                attribute_path: AttributePath {
                                                                    attributes: [
                                                                        Raw {
                                                                            content: "isx86_64",
                                                                            position: (72, 30),
                                                                        },
                                                                    ],
                                                                },
                                                                default: None,
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "--with-jvm-features=zgc",
                                                                        position: (72, 40),
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                    BinaryOperation {
                                                        operator: Concatenation,
                                                        operands: [
                                                            FunctionApplication {
                                                                function: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "lib",
                                                                        position: (73, 10),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "optional",
                                                                                position: (73, 14),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                                arguments: [
                                                                    Variable {
                                                                        identifier: "headless",
                                                                        position: (73, 23),
                                                                    },
                                                                    String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "--enable-headless-only",
                                                                                position: (73, 33),
                                                                            },
                                                                        ],
                                                                    },
                                                                ],
                                                            },
                                                            FunctionApplication {
                                                                function: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "lib",
                                                                        position: (74, 10),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "optional",
                                                                                position: (74, 14),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                                arguments: [
                                                                    BinaryOperation {
                                                                        operator: LogicalAnd,
                                                                        operands: [
                                                                            UnaryOperation {
                                                                                operator: Not,
                                                                                operand: Variable {
                                                                                    identifier: "headless",
                                                                                    position: (74, 25),
                                                                                },
                                                                            },
                                                                            Variable {
                                                                                identifier: "enableJavaFX",
                                                                                position: (74, 37),
                                                                            },
                                                                        ],
                                                                    },
                                                                    String {
                                                                        parts: [
                                                                            Raw {
                                                                                content: "--with-import-modules=",
                                                                                position: (74, 52),
                                                                            },
                                                                            Expression {
                                                                                expression: Variable {
                                                                                    identifier: "openjfx",
                                                                                    position: (74, 76),
                                                                                },
                                                                            },
                                                                        ],
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "separateDebugInfo",
                                                position: (76, 5),
                                            },
                                        ],
                                    },
                                    Variable {
                                        identifier: "true",
                                        position: (76, 25),
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "NIX_CFLAGS_COMPILE",
                                                position: (78, 5),
                                            },
                                        ],
                                    },
                                    List {
                                        elements: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "-Wno-error",
                                                        position: (78, 29),
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "NIX_LDFLAGS",
                                                position: (80, 5),
                                            },
                                        ],
                                    },
                                    BinaryOperation {
                                        operator: Concatenation,
                                        operands: [
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (80, 19),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionals",
                                                                position: (80, 23),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    UnaryOperation {
                                                        operator: Not,
                                                        operand: Variable {
                                                            identifier: "headless",
                                                            position: (80, 35),
                                                        },
                                                    },
                                                    List {
                                                        elements: [
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lfontconfig",
                                                                        position: (81, 8),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lcups",
                                                                        position: (81, 23),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lXinerama",
                                                                        position: (81, 32),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lXrandr",
                                                                        position: (81, 45),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lmagic",
                                                                        position: (81, 56),
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "lib",
                                                        position: (82, 10),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "optionals",
                                                                position: (82, 14),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    BinaryOperation {
                                                        operator: LogicalAnd,
                                                        operands: [
                                                            UnaryOperation {
                                                                operator: Not,
                                                                operand: Variable {
                                                                    identifier: "headless",
                                                                    position: (82, 26),
                                                                },
                                                            },
                                                            Variable {
                                                                identifier: "enableGnome2",
                                                                position: (82, 38),
                                                            },
                                                        ],
                                                    },
                                                    List {
                                                        elements: [
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lgtk-3",
                                                                        position: (83, 8),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lgio-2.0",
                                                                        position: (83, 18),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lgnomevfs-2",
                                                                        position: (83, 30),
                                                                    },
                                                                ],
                                                            },
                                                            String {
                                                                parts: [
                                                                    Raw {
                                                                        content: "-lgconf-2",
                                                                        position: (83, 45),
                                                                    },
                                                                ],
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "enableParallelBuilding",
                                                position: (90, 5),
                                            },
                                        ],
                                    },
                                    Variable {
                                        identifier: "false",
                                        position: (90, 30),
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "buildFlags",
                                                position: (92, 5),
                                            },
                                        ],
                                    },
                                    List {
                                        elements: [
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "all",
                                                        position: (92, 21),
                                                    },
                                                ],
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "installPhase",
                                                position: (94, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "mkdir -p $out/lib\n\nmv build/*/images/jdk $out/lib/openjdk\n\n# Remove some broken manpages.\nrm -rf $out/lib/openjdk/man/ja*\n\n# Mirror some stuff in top-level.\nmkdir -p $out/share\nln -s $out/lib/openjdk/include $out/include\nln -s $out/lib/openjdk/man $out/share/man\n\n# jni.h expects jni_md.h to be in the header search path.\nln -s $out/include/linux/*_md.h $out/include/\n\n# Remove crap from the installation.\nrm -rf $out/lib/openjdk/demo\n",
                                                position: (95, 1),
                                            },
                                            Expression {
                                                expression: FunctionApplication {
                                                    function: PropertyAccess {
                                                        expression: Variable {
                                                            identifier: "lib",
                                                            position: (112, 9),
                                                        },
                                                        attribute_path: AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "optionalString",
                                                                    position: (112, 13),
                                                                },
                                                            ],
                                                        },
                                                        default: None,
                                                    },
                                                    arguments: [
                                                        Variable {
                                                            identifier: "headless",
                                                            position: (112, 28),
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "rm $out/lib/openjdk/lib/{libjsound,libfontmanager}.so\n",
                                                                    position: (113, 1),
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                            },
                                            Raw {
                                                content: "\n\nln -s $out/lib/openjdk/bin $out/bin\n",
                                                position: (114, 10),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "preFixup",
                                                position: (119, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "# Propagate the setJavaClassPath setup hook so that any package\n# that depends on the JDK has $CLASSPATH set up properly.\nmkdir -p $out/nix-support\n#TODO or printWords?  cf https://github.com/NixOS/nixpkgs/pull/27427#issuecomment-317293040\necho -n \"",
                                                position: (120, 1),
                                            },
                                            Expression {
                                                expression: Variable {
                                                    identifier: "setJavaClassPath",
                                                    position: (124, 18),
                                                },
                                            },
                                            Raw {
                                                content: "\" > $out/nix-support/propagated-build-inputs\n\n# Set JAVA_HOME automatically.\nmkdir -p $out/nix-support\ncat <<EOF > $out/nix-support/setup-hook\nif [ -z \"\\",
                                                position: (124, 35),
                                            },
                                            Raw {
                                                content: "$",
                                                position: (129, 17),
                                            },
                                            Raw {
                                                content: "{JAVA_HOME-}\" ]; then export JAVA_HOME=$out/lib/openjdk; fi\nEOF\n",
                                                position: (129, 20),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "postFixup",
                                                position: (133, 5),
                                            },
                                        ],
                                    },
                                    String {
                                        parts: [
                                            Raw {
                                                content: "# Build the set of output library directories to rpath against\nLIBDIRS=\"\"\nfor output in $outputs; do\n  if [ \"$output\" = debug ]; then continue; fi\n  LIBDIRS=\"$(find $(eval echo \\$$output) -name \\*.so\\* -exec dirname {} \\+ | sort | uniq | tr '\\n' ':'):$LIBDIRS\"\ndone\n# Add the local library paths to remove dependencies on the bootstrap\nfor output in $outputs; do\n  if [ \"$output\" = debug ]; then continue; fi\n  OUTPUTDIR=$(eval echo \\$$output)\n  BINLIBS=$(find $OUTPUTDIR/bin/ -type f; find $OUTPUTDIR -name \\*.so\\*)\n  echo \"$BINLIBS\" | while read i; do\n    patchelf --set-rpath \"$LIBDIRS:$(patchelf --print-rpath \"$i\")\" \"$i\" || true\n    patchelf --shrink-rpath \"$i\" || true\n  done\ndone\n",
                                                position: (134, 1),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "disallowedReferences",
                                                position: (152, 5),
                                            },
                                        ],
                                    },
                                    List {
                                        elements: [
                                            Variable {
                                                identifier: "openjdk11",
                                                position: (152, 30),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "meta",
                                                position: (154, 5),
                                            },
                                        ],
                                    },
                                    FunctionApplication {
                                        function: Variable {
                                            identifier: "import",
                                            position: (154, 12),
                                        },
                                        arguments: [
                                            Path {
                                                parts: [
                                                    Raw {
                                                        content: "./meta.nix",
                                                        position: (154, 19),
                                                    },
                                                ],
                                            },
                                            Variable {
                                                identifier: "lib",
                                                position: (154, 30),
                                            },
                                        ],
                                    },
                                ),
                                KeyValue(
                                    AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "passthru",
                                                position: (156, 5),
                                            },
                                        ],
                                    },
                                    Map {
                                        bindings: [
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "architecture",
                                                            position: (157, 7),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [],
                                                },
                                            ),
                                            KeyValue(
                                                AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "home",
                                                            position: (158, 7),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Expression {
                                                            expression: Variable {
                                                                identifier: "openjdk",
                                                                position: (158, 17),
                                                            },
                                                        },
                                                        Raw {
                                                            content: "/lib/openjdk",
                                                            position: (158, 25),
                                                        },
                                                    ],
                                                },
                                            ),
                                            Inherit(
                                                None,
                                                [
                                                    Raw {
                                                        content: "gtk3",
                                                        position: (159, 15),
                                                    },
                                                ],
                                            ),
                                        ],
                                        recursive: false,
                                    },
                                ),
                            ],
                            recursive: true,
                        },
                    ],
                },
            ),
        ],
        target: Variable {
            identifier: "openjdk",
            position: (162, 4),
        },
    },
}