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