---
LetIn {
 bindings: [
  Inherit {
   from: Some(
    FunctionApplication {
     function: Variable {
      identifier: "import",
      position: (8, 12),
     },
     arguments: [
      Path {
       parts: [
        Raw {
         content: "./fixed-points.nix",
         position: (8, 19),
        },
       ],
       position: (8, 19),
      },
      Map {
       bindings: [
        Inherit {
         from: None,
         attributes: [
          Raw {
           content: "lib",
           position: (8, 48),
          },
         ],
        },
       ],
       recursive: false,
       position: (8, 38),
      },
     ],
    },
   ),
   attributes: [
    Raw {
     content: "makeExtensible",
     position: (8, 56),
    },
   ],
  },
  Binding {
   from: AttributePath {
    parts: [
     Raw {
      content: "lib",
      position: (10, 3),
     },
    ],
   },
   to: FunctionApplication {
    function: Variable {
     identifier: "makeExtensible",
     position: (10, 9),
    },
    arguments: [
     Parentheses {
      expression: Function {
       argument: Simple {
        identifier: "self",
       },
       definition: LetIn {
        bindings: [
         Binding {
          from: AttributePath {
           parts: [
            Raw {
             content: "callLibs",
             position: (11, 5),
            },
           ],
          },
          to: Function {
           argument: Simple {
            identifier: "file",
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "import",
             position: (11, 22),
            },
            arguments: [
             Variable {
              identifier: "file",
              position: (11, 29),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "lib",
                   position: (11, 36),
                  },
                 ],
                },
                to: Variable {
                 identifier: "self",
                 position: (11, 42),
                },
               },
              ],
              recursive: false,
              position: (11, 34),
             },
            ],
           },
           position: (11, 16),
          },
         },
        ],
        target: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "trivial",
              position: (15, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (15, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./trivial.nix",
                position: (15, 24),
               },
              ],
              position: (15, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "fixedPoints",
              position: (16, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (16, 19),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./fixed-points.nix",
                position: (16, 28),
               },
              ],
              position: (16, 28),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "attrsets",
              position: (19, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (19, 16),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./attrsets.nix",
                position: (19, 25),
               },
              ],
              position: (19, 25),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "lists",
              position: (20, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (20, 13),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./lists.nix",
                position: (20, 22),
               },
              ],
              position: (20, 22),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "strings",
              position: (21, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (21, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./strings.nix",
                position: (21, 24),
               },
              ],
              position: (21, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "stringsWithDeps",
              position: (22, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (22, 23),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./strings-with-deps.nix",
                position: (22, 32),
               },
              ],
              position: (22, 32),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "customisation",
              position: (25, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (25, 21),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./customisation.nix",
                position: (25, 30),
               },
              ],
              position: (25, 30),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "maintainers",
              position: (26, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "import",
             position: (26, 19),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "../maintainers/maintainer-list.nix",
                position: (26, 26),
               },
              ],
              position: (26, 26),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "teams",
              position: (27, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (27, 13),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "../maintainers/team-list.nix",
                position: (27, 22),
               },
              ],
              position: (27, 22),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "meta",
              position: (28, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (28, 12),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./meta.nix",
                position: (28, 21),
               },
              ],
              position: (28, 21),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "sources",
              position: (29, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (29, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./sources.nix",
                position: (29, 24),
               },
              ],
              position: (29, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "versions",
              position: (30, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (30, 16),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./versions.nix",
                position: (30, 25),
               },
              ],
              position: (30, 25),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "modules",
              position: (33, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (33, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./modules.nix",
                position: (33, 24),
               },
              ],
              position: (33, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "options",
              position: (34, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (34, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./options.nix",
                position: (34, 24),
               },
              ],
              position: (34, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "types",
              position: (35, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (35, 13),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./types.nix",
                position: (35, 22),
               },
              ],
              position: (35, 22),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "licenses",
              position: (38, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (38, 16),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./licenses.nix",
                position: (38, 25),
               },
              ],
              position: (38, 25),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "systems",
              position: (39, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (39, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./systems",
                position: (39, 24),
               },
              ],
              position: (39, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "cli",
              position: (42, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (42, 11),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./cli.nix",
                position: (42, 20),
               },
              ],
              position: (42, 20),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "generators",
              position: (43, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (43, 18),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./generators.nix",
                position: (43, 27),
               },
              ],
              position: (43, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "asserts",
              position: (46, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (46, 15),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./asserts.nix",
                position: (46, 24),
               },
              ],
              position: (46, 24),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "debug",
              position: (47, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (47, 13),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./debug.nix",
                position: (47, 22),
               },
              ],
              position: (47, 22),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "misc",
              position: (48, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (48, 12),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./deprecated.nix",
                position: (48, 21),
               },
              ],
              position: (48, 21),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "fetchers",
              position: (51, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (51, 16),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./fetchers.nix",
                position: (51, 25),
               },
              ],
              position: (51, 25),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "filesystem",
              position: (54, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (54, 18),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./filesystem.nix",
                position: (54, 27),
               },
              ],
              position: (54, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "platforms",
              position: (57, 5),
             },
            ],
           },
           to: PropertyAccess {
            expression: Variable {
             identifier: "self",
             position: (57, 17),
            },
            attribute_path: AttributePath {
             parts: [
              Raw {
               content: "systems",
               position: (57, 22),
              },
              Raw {
               content: "doubles",
               position: (57, 30),
              },
             ],
            },
            default: None,
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "kernel",
              position: (60, 5),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "callLibs",
             position: (60, 14),
            },
            arguments: [
             Path {
              parts: [
               Raw {
                content: "./kernel.nix",
                position: (60, 23),
               },
              ],
              position: (60, 23),
             },
            ],
           },
          },
          Inherit {
           from: Some(
            Variable {
             identifier: "builtins",
             position: (62, 14),
            },
           ),
           attributes: [
            Raw {
             content: "add",
             position: (62, 24),
            },
            Raw {
             content: "addErrorContext",
             position: (62, 28),
            },
            Raw {
             content: "attrNames",
             position: (62, 44),
            },
            Raw {
             content: "concatLists",
             position: (62, 54),
            },
            Raw {
             content: "deepSeq",
             position: (63, 7),
            },
            Raw {
             content: "elem",
             position: (63, 15),
            },
            Raw {
             content: "elemAt",
             position: (63, 20),
            },
            Raw {
             content: "filter",
             position: (63, 27),
            },
            Raw {
             content: "genericClosure",
             position: (63, 34),
            },
            Raw {
             content: "genList",
             position: (63, 49),
            },
            Raw {
             content: "getAttr",
             position: (63, 57),
            },
            Raw {
             content: "hasAttr",
             position: (64, 7),
            },
            Raw {
             content: "head",
             position: (64, 15),
            },
            Raw {
             content: "isAttrs",
             position: (64, 20),
            },
            Raw {
             content: "isBool",
             position: (64, 28),
            },
            Raw {
             content: "isInt",
             position: (64, 35),
            },
            Raw {
             content: "isList",
             position: (64, 41),
            },
            Raw {
             content: "isString",
             position: (64, 48),
            },
            Raw {
             content: "length",
             position: (64, 57),
            },
            Raw {
             content: "lessThan",
             position: (65, 7),
            },
            Raw {
             content: "listToAttrs",
             position: (65, 16),
            },
            Raw {
             content: "pathExists",
             position: (65, 28),
            },
            Raw {
             content: "readFile",
             position: (65, 39),
            },
            Raw {
             content: "replaceStrings",
             position: (65, 48),
            },
            Raw {
             content: "seq",
             position: (65, 63),
            },
            Raw {
             content: "stringLength",
             position: (66, 7),
            },
            Raw {
             content: "sub",
             position: (66, 20),
            },
            Raw {
             content: "substring",
             position: (66, 24),
            },
            Raw {
             content: "tail",
             position: (66, 34),
            },
            Raw {
             content: "trace",
             position: (66, 39),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (67, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "trivial",
                position: (67, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "id",
             position: (67, 28),
            },
            Raw {
             content: "const",
             position: (67, 31),
            },
            Raw {
             content: "pipe",
             position: (67, 37),
            },
            Raw {
             content: "concat",
             position: (67, 42),
            },
            Raw {
             content: "or",
             position: (67, 49),
            },
            Raw {
             content: "and",
             position: (67, 52),
            },
            Raw {
             content: "bitAnd",
             position: (67, 56),
            },
            Raw {
             content: "bitOr",
             position: (67, 63),
            },
            Raw {
             content: "bitXor",
             position: (67, 69),
            },
            Raw {
             content: "bitNot",
             position: (68, 7),
            },
            Raw {
             content: "boolToString",
             position: (68, 14),
            },
            Raw {
             content: "mergeAttrs",
             position: (68, 27),
            },
            Raw {
             content: "flip",
             position: (68, 38),
            },
            Raw {
             content: "mapNullable",
             position: (68, 43),
            },
            Raw {
             content: "inNixShell",
             position: (68, 55),
            },
            Raw {
             content: "isFloat",
             position: (68, 66),
            },
            Raw {
             content: "min",
             position: (68, 74),
            },
            Raw {
             content: "max",
             position: (68, 78),
            },
            Raw {
             content: "importJSON",
             position: (69, 7),
            },
            Raw {
             content: "importTOML",
             position: (69, 18),
            },
            Raw {
             content: "warn",
             position: (69, 29),
            },
            Raw {
             content: "warnIf",
             position: (69, 34),
            },
            Raw {
             content: "warnIfNot",
             position: (69, 41),
            },
            Raw {
             content: "throwIf",
             position: (69, 51),
            },
            Raw {
             content: "throwIfNot",
             position: (69, 59),
            },
            Raw {
             content: "checkListOfEnum",
             position: (69, 70),
            },
            Raw {
             content: "info",
             position: (70, 7),
            },
            Raw {
             content: "showWarnings",
             position: (70, 12),
            },
            Raw {
             content: "nixpkgsVersion",
             position: (70, 25),
            },
            Raw {
             content: "version",
             position: (70, 40),
            },
            Raw {
             content: "isInOldestRelease",
             position: (70, 48),
            },
            Raw {
             content: "mod",
             position: (71, 7),
            },
            Raw {
             content: "compare",
             position: (71, 11),
            },
            Raw {
             content: "splitByAndCompare",
             position: (71, 19),
            },
            Raw {
             content: "functionArgs",
             position: (72, 7),
            },
            Raw {
             content: "setFunctionArgs",
             position: (72, 20),
            },
            Raw {
             content: "isFunction",
             position: (72, 36),
            },
            Raw {
             content: "toFunction",
             position: (72, 47),
            },
            Raw {
             content: "toHexString",
             position: (73, 7),
            },
            Raw {
             content: "toBaseDigits",
             position: (73, 19),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (74, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "fixedPoints",
                position: (74, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "fix",
             position: (74, 32),
            },
            Raw {
             content: "fix'",
             position: (74, 36),
            },
            Raw {
             content: "converge",
             position: (74, 41),
            },
            Raw {
             content: "extends",
             position: (74, 50),
            },
            Raw {
             content: "composeExtensions",
             position: (74, 58),
            },
            Raw {
             content: "composeManyExtensions",
             position: (75, 7),
            },
            Raw {
             content: "makeExtensible",
             position: (75, 29),
            },
            Raw {
             content: "makeExtensibleWithCustomName",
             position: (75, 44),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (76, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "attrsets",
                position: (76, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "attrByPath",
             position: (76, 29),
            },
            Raw {
             content: "hasAttrByPath",
             position: (76, 40),
            },
            Raw {
             content: "setAttrByPath",
             position: (76, 54),
            },
            Raw {
             content: "getAttrFromPath",
             position: (77, 7),
            },
            Raw {
             content: "attrVals",
             position: (77, 23),
            },
            Raw {
             content: "attrValues",
             position: (77, 32),
            },
            Raw {
             content: "getAttrs",
             position: (77, 43),
            },
            Raw {
             content: "catAttrs",
             position: (77, 52),
            },
            Raw {
             content: "filterAttrs",
             position: (77, 61),
            },
            Raw {
             content: "filterAttrsRecursive",
             position: (78, 7),
            },
            Raw {
             content: "foldAttrs",
             position: (78, 28),
            },
            Raw {
             content: "collect",
             position: (78, 38),
            },
            Raw {
             content: "nameValuePair",
             position: (78, 46),
            },
            Raw {
             content: "mapAttrs",
             position: (78, 60),
            },
            Raw {
             content: "mapAttrs'",
             position: (79, 7),
            },
            Raw {
             content: "mapAttrsToList",
             position: (79, 17),
            },
            Raw {
             content: "mapAttrsRecursive",
             position: (79, 32),
            },
            Raw {
             content: "mapAttrsRecursiveCond",
             position: (79, 50),
            },
            Raw {
             content: "genAttrs",
             position: (80, 7),
            },
            Raw {
             content: "isDerivation",
             position: (80, 16),
            },
            Raw {
             content: "toDerivation",
             position: (80, 29),
            },
            Raw {
             content: "optionalAttrs",
             position: (80, 42),
            },
            Raw {
             content: "zipAttrsWithNames",
             position: (81, 7),
            },
            Raw {
             content: "zipAttrsWith",
             position: (81, 25),
            },
            Raw {
             content: "zipAttrs",
             position: (81, 38),
            },
            Raw {
             content: "recursiveUpdateUntil",
             position: (81, 47),
            },
            Raw {
             content: "recursiveUpdate",
             position: (82, 7),
            },
            Raw {
             content: "matchAttrs",
             position: (82, 23),
            },
            Raw {
             content: "overrideExisting",
             position: (82, 34),
            },
            Raw {
             content: "showAttrPath",
             position: (82, 51),
            },
            Raw {
             content: "getOutput",
             position: (82, 64),
            },
            Raw {
             content: "getBin",
             position: (82, 74),
            },
            Raw {
             content: "getLib",
             position: (83, 7),
            },
            Raw {
             content: "getDev",
             position: (83, 14),
            },
            Raw {
             content: "getMan",
             position: (83, 21),
            },
            Raw {
             content: "chooseDevOutputs",
             position: (83, 28),
            },
            Raw {
             content: "zipWithNames",
             position: (83, 45),
            },
            Raw {
             content: "zip",
             position: (83, 58),
            },
            Raw {
             content: "recurseIntoAttrs",
             position: (84, 7),
            },
            Raw {
             content: "dontRecurseIntoAttrs",
             position: (84, 24),
            },
            Raw {
             content: "cartesianProductOfSets",
             position: (84, 45),
            },
            Raw {
             content: "updateManyAttrsByPath",
             position: (85, 7),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (86, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "lists",
                position: (86, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "singleton",
             position: (86, 26),
            },
            Raw {
             content: "forEach",
             position: (86, 36),
            },
            Raw {
             content: "foldr",
             position: (86, 44),
            },
            Raw {
             content: "fold",
             position: (86, 50),
            },
            Raw {
             content: "foldl",
             position: (86, 55),
            },
            Raw {
             content: "foldl'",
             position: (86, 61),
            },
            Raw {
             content: "imap0",
             position: (86, 68),
            },
            Raw {
             content: "imap1",
             position: (86, 74),
            },
            Raw {
             content: "concatMap",
             position: (87, 7),
            },
            Raw {
             content: "flatten",
             position: (87, 17),
            },
            Raw {
             content: "remove",
             position: (87, 25),
            },
            Raw {
             content: "findSingle",
             position: (87, 32),
            },
            Raw {
             content: "findFirst",
             position: (87, 43),
            },
            Raw {
             content: "any",
             position: (87, 53),
            },
            Raw {
             content: "all",
             position: (87, 57),
            },
            Raw {
             content: "count",
             position: (87, 61),
            },
            Raw {
             content: "optional",
             position: (88, 7),
            },
            Raw {
             content: "optionals",
             position: (88, 16),
            },
            Raw {
             content: "toList",
             position: (88, 26),
            },
            Raw {
             content: "range",
             position: (88, 33),
            },
            Raw {
             content: "partition",
             position: (88, 39),
            },
            Raw {
             content: "zipListsWith",
             position: (88, 49),
            },
            Raw {
             content: "zipLists",
             position: (88, 62),
            },
            Raw {
             content: "reverseList",
             position: (89, 7),
            },
            Raw {
             content: "listDfs",
             position: (89, 19),
            },
            Raw {
             content: "toposort",
             position: (89, 27),
            },
            Raw {
             content: "sort",
             position: (89, 36),
            },
            Raw {
             content: "naturalSort",
             position: (89, 41),
            },
            Raw {
             content: "compareLists",
             position: (89, 53),
            },
            Raw {
             content: "take",
             position: (89, 66),
            },
            Raw {
             content: "drop",
             position: (90, 7),
            },
            Raw {
             content: "sublist",
             position: (90, 12),
            },
            Raw {
             content: "last",
             position: (90, 20),
            },
            Raw {
             content: "init",
             position: (90, 25),
            },
            Raw {
             content: "crossLists",
             position: (90, 30),
            },
            Raw {
             content: "unique",
             position: (90, 41),
            },
            Raw {
             content: "intersectLists",
             position: (90, 48),
            },
            Raw {
             content: "subtractLists",
             position: (91, 7),
            },
            Raw {
             content: "mutuallyExclusive",
             position: (91, 21),
            },
            Raw {
             content: "groupBy",
             position: (91, 39),
            },
            Raw {
             content: "groupBy'",
             position: (91, 47),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (92, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "strings",
                position: (92, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "concatStrings",
             position: (92, 28),
            },
            Raw {
             content: "concatMapStrings",
             position: (92, 42),
            },
            Raw {
             content: "concatImapStrings",
             position: (92, 59),
            },
            Raw {
             content: "intersperse",
             position: (93, 7),
            },
            Raw {
             content: "concatStringsSep",
             position: (93, 19),
            },
            Raw {
             content: "concatMapStringsSep",
             position: (93, 36),
            },
            Raw {
             content: "concatImapStringsSep",
             position: (94, 7),
            },
            Raw {
             content: "makeSearchPath",
             position: (94, 28),
            },
            Raw {
             content: "makeSearchPathOutput",
             position: (94, 43),
            },
            Raw {
             content: "makeLibraryPath",
             position: (95, 7),
            },
            Raw {
             content: "makeBinPath",
             position: (95, 23),
            },
            Raw {
             content: "optionalString",
             position: (95, 35),
            },
            Raw {
             content: "hasInfix",
             position: (96, 7),
            },
            Raw {
             content: "hasPrefix",
             position: (96, 16),
            },
            Raw {
             content: "hasSuffix",
             position: (96, 26),
            },
            Raw {
             content: "stringToCharacters",
             position: (96, 36),
            },
            Raw {
             content: "stringAsChars",
             position: (96, 55),
            },
            Raw {
             content: "escape",
             position: (96, 69),
            },
            Raw {
             content: "escapeShellArg",
             position: (97, 7),
            },
            Raw {
             content: "escapeShellArgs",
             position: (97, 22),
            },
            Raw {
             content: "escapeRegex",
             position: (97, 38),
            },
            Raw {
             content: "escapeXML",
             position: (97, 50),
            },
            Raw {
             content: "replaceChars",
             position: (97, 60),
            },
            Raw {
             content: "lowerChars",
             position: (97, 73),
            },
            Raw {
             content: "upperChars",
             position: (98, 7),
            },
            Raw {
             content: "toLower",
             position: (98, 18),
            },
            Raw {
             content: "toUpper",
             position: (98, 26),
            },
            Raw {
             content: "addContextFrom",
             position: (98, 34),
            },
            Raw {
             content: "splitString",
             position: (98, 49),
            },
            Raw {
             content: "removePrefix",
             position: (99, 7),
            },
            Raw {
             content: "removeSuffix",
             position: (99, 20),
            },
            Raw {
             content: "versionOlder",
             position: (99, 33),
            },
            Raw {
             content: "versionAtLeast",
             position: (99, 46),
            },
            Raw {
             content: "getName",
             position: (100, 7),
            },
            Raw {
             content: "getVersion",
             position: (100, 15),
            },
            Raw {
             content: "nameFromURL",
             position: (101, 7),
            },
            Raw {
             content: "enableFeature",
             position: (101, 19),
            },
            Raw {
             content: "enableFeatureAs",
             position: (101, 33),
            },
            Raw {
             content: "withFeature",
             position: (101, 49),
            },
            Raw {
             content: "withFeatureAs",
             position: (102, 7),
            },
            Raw {
             content: "fixedWidthString",
             position: (102, 21),
            },
            Raw {
             content: "fixedWidthNumber",
             position: (102, 38),
            },
            Raw {
             content: "isStorePath",
             position: (102, 55),
            },
            Raw {
             content: "toInt",
             position: (103, 7),
            },
            Raw {
             content: "readPathsFromFile",
             position: (103, 13),
            },
            Raw {
             content: "fileContents",
             position: (103, 31),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (104, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "stringsWithDeps",
                position: (104, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "textClosureList",
             position: (104, 36),
            },
            Raw {
             content: "textClosureMap",
             position: (104, 52),
            },
            Raw {
             content: "noDepEntry",
             position: (105, 7),
            },
            Raw {
             content: "fullDepEntry",
             position: (105, 18),
            },
            Raw {
             content: "packEntry",
             position: (105, 31),
            },
            Raw {
             content: "stringAfter",
             position: (105, 41),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (106, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "customisation",
                position: (106, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "overrideDerivation",
             position: (106, 34),
            },
            Raw {
             content: "makeOverridable",
             position: (106, 53),
            },
            Raw {
             content: "callPackageWith",
             position: (107, 7),
            },
            Raw {
             content: "callPackagesWith",
             position: (107, 23),
            },
            Raw {
             content: "extendDerivation",
             position: (107, 40),
            },
            Raw {
             content: "hydraJob",
             position: (107, 57),
            },
            Raw {
             content: "makeScope",
             position: (108, 7),
            },
            Raw {
             content: "makeScopeWithSplicing",
             position: (108, 17),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (109, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "meta",
                position: (109, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "addMetaAttrs",
             position: (109, 25),
            },
            Raw {
             content: "dontDistribute",
             position: (109, 38),
            },
            Raw {
             content: "setName",
             position: (109, 53),
            },
            Raw {
             content: "updateName",
             position: (109, 61),
            },
            Raw {
             content: "appendToName",
             position: (110, 7),
            },
            Raw {
             content: "mapDerivationAttrset",
             position: (110, 20),
            },
            Raw {
             content: "setPrio",
             position: (110, 41),
            },
            Raw {
             content: "lowPrio",
             position: (110, 49),
            },
            Raw {
             content: "lowPrioSet",
             position: (110, 57),
            },
            Raw {
             content: "hiPrio",
             position: (110, 68),
            },
            Raw {
             content: "hiPrioSet",
             position: (111, 7),
            },
            Raw {
             content: "getLicenseFromSpdxId",
             position: (111, 17),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (112, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "sources",
                position: (112, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "pathType",
             position: (112, 28),
            },
            Raw {
             content: "pathIsDirectory",
             position: (112, 37),
            },
            Raw {
             content: "cleanSourceFilter",
             position: (112, 53),
            },
            Raw {
             content: "cleanSource",
             position: (113, 7),
            },
            Raw {
             content: "sourceByRegex",
             position: (113, 19),
            },
            Raw {
             content: "sourceFilesBySuffices",
             position: (113, 33),
            },
            Raw {
             content: "commitIdFromGitRepo",
             position: (114, 7),
            },
            Raw {
             content: "cleanSourceWith",
             position: (114, 27),
            },
            Raw {
             content: "pathHasContext",
             position: (114, 43),
            },
            Raw {
             content: "canCleanSource",
             position: (115, 7),
            },
            Raw {
             content: "pathIsRegularFile",
             position: (115, 22),
            },
            Raw {
             content: "pathIsGitRepo",
             position: (115, 40),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (116, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "modules",
                position: (116, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "evalModules",
             position: (116, 28),
            },
            Raw {
             content: "setDefaultModuleLocation",
             position: (116, 40),
            },
            Raw {
             content: "unifyModuleSyntax",
             position: (117, 7),
            },
            Raw {
             content: "applyModuleArgsIfFunction",
             position: (117, 25),
            },
            Raw {
             content: "mergeModules",
             position: (117, 51),
            },
            Raw {
             content: "mergeModules'",
             position: (118, 7),
            },
            Raw {
             content: "mergeOptionDecls",
             position: (118, 21),
            },
            Raw {
             content: "evalOptionValue",
             position: (118, 38),
            },
            Raw {
             content: "mergeDefinitions",
             position: (118, 54),
            },
            Raw {
             content: "pushDownProperties",
             position: (119, 7),
            },
            Raw {
             content: "dischargeProperties",
             position: (119, 26),
            },
            Raw {
             content: "filterOverrides",
             position: (119, 46),
            },
            Raw {
             content: "sortProperties",
             position: (120, 7),
            },
            Raw {
             content: "fixupOptionType",
             position: (120, 22),
            },
            Raw {
             content: "mkIf",
             position: (120, 38),
            },
            Raw {
             content: "mkAssert",
             position: (120, 43),
            },
            Raw {
             content: "mkMerge",
             position: (120, 52),
            },
            Raw {
             content: "mkOverride",
             position: (120, 60),
            },
            Raw {
             content: "mkOptionDefault",
             position: (121, 7),
            },
            Raw {
             content: "mkDefault",
             position: (121, 23),
            },
            Raw {
             content: "mkImageMediaOverride",
             position: (121, 33),
            },
            Raw {
             content: "mkForce",
             position: (121, 54),
            },
            Raw {
             content: "mkVMOverride",
             position: (121, 62),
            },
            Raw {
             content: "mkFixStrictness",
             position: (122, 7),
            },
            Raw {
             content: "mkOrder",
             position: (122, 23),
            },
            Raw {
             content: "mkBefore",
             position: (122, 31),
            },
            Raw {
             content: "mkAfter",
             position: (122, 40),
            },
            Raw {
             content: "mkAliasDefinitions",
             position: (122, 48),
            },
            Raw {
             content: "mkAliasAndWrapDefinitions",
             position: (123, 7),
            },
            Raw {
             content: "fixMergeModules",
             position: (123, 33),
            },
            Raw {
             content: "mkRemovedOptionModule",
             position: (123, 49),
            },
            Raw {
             content: "mkRenamedOptionModule",
             position: (124, 7),
            },
            Raw {
             content: "mkRenamedOptionModuleWith",
             position: (124, 29),
            },
            Raw {
             content: "mkMergedOptionModule",
             position: (125, 7),
            },
            Raw {
             content: "mkChangedOptionModule",
             position: (125, 28),
            },
            Raw {
             content: "mkAliasOptionModule",
             position: (126, 7),
            },
            Raw {
             content: "mkDerivedConfig",
             position: (126, 27),
            },
            Raw {
             content: "doRename",
             position: (126, 43),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (127, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "options",
                position: (127, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "isOption",
             position: (127, 28),
            },
            Raw {
             content: "mkEnableOption",
             position: (127, 37),
            },
            Raw {
             content: "mkSinkUndeclaredOptions",
             position: (127, 52),
            },
            Raw {
             content: "mergeDefaultOption",
             position: (128, 7),
            },
            Raw {
             content: "mergeOneOption",
             position: (128, 26),
            },
            Raw {
             content: "mergeEqualOption",
             position: (128, 41),
            },
            Raw {
             content: "mergeUniqueOption",
             position: (128, 58),
            },
            Raw {
             content: "getValues",
             position: (129, 7),
            },
            Raw {
             content: "getFiles",
             position: (129, 17),
            },
            Raw {
             content: "optionAttrSetToDocList",
             position: (130, 7),
            },
            Raw {
             content: "optionAttrSetToDocList'",
             position: (130, 30),
            },
            Raw {
             content: "scrubOptionValue",
             position: (131, 7),
            },
            Raw {
             content: "literalExpression",
             position: (131, 24),
            },
            Raw {
             content: "literalExample",
             position: (131, 42),
            },
            Raw {
             content: "literalDocBook",
             position: (131, 57),
            },
            Raw {
             content: "showOption",
             position: (132, 7),
            },
            Raw {
             content: "showFiles",
             position: (132, 18),
            },
            Raw {
             content: "unknownModule",
             position: (132, 28),
            },
            Raw {
             content: "mkOption",
             position: (132, 42),
            },
            Raw {
             content: "mkPackageOption",
             position: (132, 51),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (133, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "types",
                position: (133, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "isType",
             position: (133, 26),
            },
            Raw {
             content: "setType",
             position: (133, 33),
            },
            Raw {
             content: "defaultTypeMerge",
             position: (133, 41),
            },
            Raw {
             content: "defaultFunctor",
             position: (133, 58),
            },
            Raw {
             content: "isOptionType",
             position: (134, 7),
            },
            Raw {
             content: "mkOptionType",
             position: (134, 20),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (135, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "asserts",
                position: (135, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "assertMsg",
             position: (136, 7),
            },
            Raw {
             content: "assertOneOf",
             position: (136, 17),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (137, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "debug",
                position: (137, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "addErrorContextToAttrs",
             position: (137, 26),
            },
            Raw {
             content: "traceIf",
             position: (137, 49),
            },
            Raw {
             content: "traceVal",
             position: (137, 57),
            },
            Raw {
             content: "traceValFn",
             position: (137, 66),
            },
            Raw {
             content: "traceXMLVal",
             position: (138, 7),
            },
            Raw {
             content: "traceXMLValMarked",
             position: (138, 19),
            },
            Raw {
             content: "traceSeq",
             position: (138, 37),
            },
            Raw {
             content: "traceSeqN",
             position: (138, 46),
            },
            Raw {
             content: "traceValSeq",
             position: (138, 56),
            },
            Raw {
             content: "traceValSeqFn",
             position: (139, 7),
            },
            Raw {
             content: "traceValSeqN",
             position: (139, 21),
            },
            Raw {
             content: "traceValSeqNFn",
             position: (139, 34),
            },
            Raw {
             content: "traceFnSeqN",
             position: (139, 49),
            },
            Raw {
             content: "traceShowVal",
             position: (139, 61),
            },
            Raw {
             content: "traceShowValMarked",
             position: (140, 7),
            },
            Raw {
             content: "showVal",
             position: (140, 26),
            },
            Raw {
             content: "traceCall",
             position: (140, 34),
            },
            Raw {
             content: "traceCall2",
             position: (140, 44),
            },
            Raw {
             content: "traceCall3",
             position: (140, 55),
            },
            Raw {
             content: "traceValIfNot",
             position: (141, 7),
            },
            Raw {
             content: "runTests",
             position: (141, 21),
            },
            Raw {
             content: "testAllTrue",
             position: (141, 30),
            },
            Raw {
             content: "traceCallXml",
             position: (141, 42),
            },
            Raw {
             content: "attrNamesToStr",
             position: (141, 55),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (142, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "misc",
                position: (142, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "maybeEnv",
             position: (142, 25),
            },
            Raw {
             content: "defaultMergeArg",
             position: (142, 34),
            },
            Raw {
             content: "defaultMerge",
             position: (142, 50),
            },
            Raw {
             content: "foldArgs",
             position: (142, 63),
            },
            Raw {
             content: "maybeAttrNullable",
             position: (143, 7),
            },
            Raw {
             content: "maybeAttr",
             position: (143, 25),
            },
            Raw {
             content: "ifEnable",
             position: (143, 35),
            },
            Raw {
             content: "checkFlag",
             position: (143, 44),
            },
            Raw {
             content: "getValue",
             position: (143, 54),
            },
            Raw {
             content: "checkReqs",
             position: (144, 7),
            },
            Raw {
             content: "uniqList",
             position: (144, 17),
            },
            Raw {
             content: "uniqListExt",
             position: (144, 26),
            },
            Raw {
             content: "condConcat",
             position: (144, 38),
            },
            Raw {
             content: "lazyGenericClosure",
             position: (144, 49),
            },
            Raw {
             content: "innerModifySumArgs",
             position: (145, 7),
            },
            Raw {
             content: "modifySumArgs",
             position: (145, 26),
            },
            Raw {
             content: "innerClosePropagation",
             position: (145, 40),
            },
            Raw {
             content: "closePropagation",
             position: (146, 7),
            },
            Raw {
             content: "mapAttrsFlatten",
             position: (146, 24),
            },
            Raw {
             content: "nvs",
             position: (146, 40),
            },
            Raw {
             content: "setAttr",
             position: (146, 44),
            },
            Raw {
             content: "setAttrMerge",
             position: (146, 52),
            },
            Raw {
             content: "mergeAttrsWithFunc",
             position: (147, 7),
            },
            Raw {
             content: "mergeAttrsConcatenateValues",
             position: (147, 26),
            },
            Raw {
             content: "mergeAttrsNoOverride",
             position: (148, 7),
            },
            Raw {
             content: "mergeAttrByFunc",
             position: (148, 28),
            },
            Raw {
             content: "mergeAttrsByFuncDefaults",
             position: (148, 44),
            },
            Raw {
             content: "mergeAttrsByFuncDefaultsClean",
             position: (149, 7),
            },
            Raw {
             content: "mergeAttrBy",
             position: (149, 37),
            },
            Raw {
             content: "fakeHash",
             position: (150, 7),
            },
            Raw {
             content: "fakeSha256",
             position: (150, 16),
            },
            Raw {
             content: "fakeSha512",
             position: (150, 27),
            },
            Raw {
             content: "nixType",
             position: (151, 7),
            },
            Raw {
             content: "imap",
             position: (151, 15),
            },
           ],
          },
          Inherit {
           from: Some(
            PropertyAccess {
             expression: Variable {
              identifier: "self",
              position: (152, 14),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "versions",
                position: (152, 19),
               },
              ],
             },
             default: None,
            },
           ),
           attributes: [
            Raw {
             content: "splitVersion",
             position: (153, 7),
            },
           ],
          },
         ],
         recursive: false,
         position: (12, 6),
        },
        position: (10, 31),
       },
       position: (10, 25),
      },
      position: (10, 24),
     },
    ],
   },
  },
 ],
 target: Variable {
  identifier: "lib",
  position: (155, 4),
 },
 position: (6, 1),
}