---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "nix",
         position: (7, 16),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "nixPackage",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (9, 16),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "package",
         position: (9, 20),
        },
        Raw {
         content: "out",
         position: (9, 28),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isNixAtLeast",
        position: (11, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "versionAtLeast",
       position: (11, 18),
      },
      arguments: [
       FunctionApplication {
        function: Variable {
         identifier: "getVersion",
         position: (11, 34),
        },
        arguments: [
         Variable {
          identifier: "nixPackage",
          position: (11, 45),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeNixBuildUser",
        position: (13, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "nr",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "name",
            position: (14, 5),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "nixbld",
            position: (14, 13),
           },
           Expression {
            expression: FunctionApplication {
             function: Variable {
              identifier: "toString",
              position: (14, 21),
             },
             arguments: [
              Variable {
               identifier: "nr",
               position: (14, 30),
              },
             ],
            },
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "value",
            position: (15, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "description",
               position: (16, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "Nix build user ",
               position: (16, 22),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (16, 39),
                },
                arguments: [
                 Variable {
                  identifier: "nr",
                  position: (16, 48),
                 },
                ],
               },
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "uid",
               position: (23, 7),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (23, 13),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "add",
                 position: (23, 22),
                },
               ],
              },
              default: None,
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (23, 26),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (23, 33),
                 },
                 Raw {
                  content: "uids",
                  position: (23, 37),
                 },
                 Raw {
                  content: "nixbld",
                  position: (23, 42),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "nr",
               position: (23, 49),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isSystemUser",
               position: (24, 7),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (24, 22),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (25, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "nixbld",
               position: (25, 16),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraGroups",
               position: (26, 7),
              },
             ],
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nixbld",
                 position: (26, 24),
                },
               ],
              },
             ],
             position: (26, 21),
            },
           ),
          ],
          recursive: false,
          position: (15, 13),
         },
        ),
       ],
       recursive: false,
       position: (13, 26),
      },
      position: (13, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "nixbldUsers",
        position: (30, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "listToAttrs",
       position: (30, 17),
      },
      arguments: [
       FunctionApplication {
        function: Variable {
         identifier: "map",
         position: (30, 30),
        },
        arguments: [
         Variable {
          identifier: "makeNixBuildUser",
          position: (30, 34),
         },
         FunctionApplication {
          function: Variable {
           identifier: "range",
           position: (30, 52),
          },
          arguments: [
           Int {
            value: 1,
            position: (30, 58),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "cfg",
             position: (30, 60),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "nrBuildUsers",
               position: (30, 64),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "nixConf",
        position: (32, 3),
       },
      ],
     },
     Assert {
      expression: FunctionApplication {
       function: Variable {
        identifier: "isNixAtLeast",
        position: (33, 12),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "2.2",
           position: (33, 26),
          },
         ],
        },
       ],
      },
      target: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "mkValueString",
            position: (36, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "v",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "v",
              position: (37, 12),
             },
             Variable {
              identifier: "null",
              position: (37, 17),
             },
            ],
            position: (37, 14),
           },
           then: String {
            parts: [],
           },
           else_: IfThenElse {
            predicate: FunctionApplication {
             function: Variable {
              identifier: "isInt",
              position: (38, 17),
             },
             arguments: [
              Variable {
               identifier: "v",
               position: (38, 23),
              },
             ],
            },
            then: FunctionApplication {
             function: Variable {
              identifier: "toString",
              position: (38, 30),
             },
             arguments: [
              Variable {
               identifier: "v",
               position: (38, 39),
              },
             ],
            },
            else_: IfThenElse {
             predicate: FunctionApplication {
              function: Variable {
               identifier: "isBool",
               position: (39, 17),
              },
              arguments: [
               Variable {
                identifier: "v",
                position: (39, 24),
               },
              ],
             },
             then: FunctionApplication {
              function: Variable {
               identifier: "boolToString",
               position: (39, 31),
              },
              arguments: [
               Variable {
                identifier: "v",
                position: (39, 44),
               },
              ],
             },
             else_: IfThenElse {
              predicate: FunctionApplication {
               function: Variable {
                identifier: "isFloat",
                position: (40, 17),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (40, 25),
                },
               ],
              },
              then: FunctionApplication {
               function: Variable {
                identifier: "floatToString",
                position: (40, 32),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (40, 46),
                },
               ],
              },
              else_: IfThenElse {
               predicate: FunctionApplication {
                function: Variable {
                 identifier: "isList",
                 position: (41, 17),
                },
                arguments: [
                 Variable {
                  identifier: "v",
                  position: (41, 24),
                 },
                ],
               },
               then: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (41, 31),
                },
                arguments: [
                 Variable {
                  identifier: "v",
                  position: (41, 40),
                 },
                ],
               },
               else_: IfThenElse {
                predicate: FunctionApplication {
                 function: Variable {
                  identifier: "isDerivation",
                  position: (42, 17),
                 },
                 arguments: [
                  Variable {
                   identifier: "v",
                   position: (42, 30),
                  },
                 ],
                },
                then: FunctionApplication {
                 function: Variable {
                  identifier: "toString",
                  position: (42, 37),
                 },
                 arguments: [
                  Variable {
                   identifier: "v",
                   position: (42, 46),
                  },
                 ],
                },
                else_: IfThenElse {
                 predicate: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "builtins",
                    position: (43, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "isPath",
                      position: (43, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Variable {
                    identifier: "v",
                    position: (43, 33),
                   },
                  ],
                 },
                 then: FunctionApplication {
                  function: Variable {
                   identifier: "toString",
                   position: (43, 40),
                  },
                  arguments: [
                   Variable {
                    identifier: "v",
                    position: (43, 49),
                   },
                  ],
                 },
                 else_: IfThenElse {
                  predicate: FunctionApplication {
                   function: Variable {
                    identifier: "isString",
                    position: (44, 17),
                   },
                   arguments: [
                    Variable {
                     identifier: "v",
                     position: (44, 26),
                    },
                   ],
                  },
                  then: Variable {
                   identifier: "v",
                   position: (44, 33),
                  },
                  else_: IfThenElse {
                   predicate: FunctionApplication {
                    function: Variable {
                     identifier: "isCoercibleToString",
                     position: (45, 17),
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (45, 37),
                     },
                    ],
                   },
                   then: FunctionApplication {
                    function: Variable {
                     identifier: "toString",
                     position: (45, 44),
                    },
                    arguments: [
                     Variable {
                      identifier: "v",
                      position: (45, 53),
                     },
                    ],
                   },
                   else_: FunctionApplication {
                    function: Variable {
                     identifier: "abort",
                     position: (46, 14),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "The nix conf value: ",
                        position: (46, 21),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toPretty",
                          position: (46, 43),
                         },
                         arguments: [
                          Map {
                           bindings: [],
                           recursive: false,
                           position: (46, 52),
                          },
                          Variable {
                           identifier: "v",
                           position: (46, 55),
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " can not be encoded",
                        position: (46, 57),
                       },
                      ],
                     },
                    ],
                   },
                   position: (45, 14),
                  },
                  position: (44, 14),
                 },
                 position: (43, 14),
                },
                position: (42, 14),
               },
               position: (41, 14),
              },
              position: (40, 14),
             },
             position: (39, 14),
            },
            position: (38, 14),
           },
           position: (37, 9),
          },
          position: (36, 23),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "mkKeyValue",
            position: (48, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "k",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: String {
            parts: [
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "escape",
                position: (48, 29),
               },
               arguments: [
                List {
                 elements: [
                  String {
                   parts: [
                    Raw {
                     content: "=",
                     position: (48, 39),
                    },
                   ],
                  },
                 ],
                 position: (48, 36),
                },
                Variable {
                 identifier: "k",
                 position: (48, 44),
                },
               ],
              },
             },
             Raw {
              content: " = ",
              position: (48, 46),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkValueString",
                position: (48, 51),
               },
               arguments: [
                Variable {
                 identifier: "v",
                 position: (48, 65),
                },
               ],
              },
             },
            ],
           },
           position: (48, 23),
          },
          position: (48, 20),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "mkKeyValuePairs",
            position: (50, 7),
           },
          ],
         },
         Function {
          argument: Some(
           "attrs",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: FunctionApplication {
           function: Variable {
            identifier: "concatStringsSep",
            position: (50, 32),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (50, 50),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (50, 55),
             },
             arguments: [
              Variable {
               identifier: "mkKeyValue",
               position: (50, 70),
              },
              Variable {
               identifier: "attrs",
               position: (50, 81),
              },
             ],
            },
           ],
          },
          position: (50, 25),
         },
        ),
       ],
       target: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "pkgs",
          position: (53, 5),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "writeTextFile",
            position: (53, 10),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (54, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "nix.conf",
               position: (54, 15),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "text",
               position: (55, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "# WARNING: this file is generated from the nix.* options in\n# your NixOS configuration, typically\n# /etc/nixos/configuration.nix.  Do not edit it!\n",
               position: (56, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "mkKeyValuePairs",
                 position: (59, 11),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (59, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "settings",
                     position: (59, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Raw {
               content: "\n",
               position: (59, 40),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (60, 11),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "extraOptions",
                   position: (60, 15),
                  },
                 ],
                },
                default: None,
               },
              },
              Raw {
               content: "\n",
               position: (60, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "checkPhase",
               position: (62, 7),
              },
             ],
            },
            IfThenElse {
             predicate: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (63, 12),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "stdenv",
                   position: (63, 17),
                  },
                  Raw {
                   content: "hostPlatform",
                   position: (63, 24),
                  },
                 ],
                },
                default: None,
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (63, 40),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "stdenv",
                   position: (63, 45),
                  },
                  Raw {
                   content: "buildPlatform",
                   position: (63, 52),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (63, 37),
             },
             then: String {
              parts: [
               Raw {
                content: "echo \"Ignoring validation for cross-compilation\"\n",
                position: (64, 1),
               },
              ],
             },
             else_: String {
              parts: [
               Raw {
                content: "echo \"Validating generated nix.conf\"\nln -s $out ./nix.conf\nset -e\nset +o pipefail\nNIX_CONF_DIR=$PWD \\\n  ",
                position: (67, 1),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (72, 15),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "package",
                    position: (72, 19),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "/bin/nix show-config ",
                position: (72, 27),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (72, 50),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "isNixAtLeast",
                    position: (72, 66),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "2.3pre",
                       position: (72, 80),
                      },
                     ],
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "--no-net",
                     position: (72, 90),
                    },
                   ],
                  },
                 ],
                },
               },
               Raw {
                content: " \\\n    ",
                position: (72, 100),
               },
               Expression {
                expression: FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (73, 17),
                 },
                 arguments: [
                  FunctionApplication {
                   function: Variable {
                    identifier: "isNixAtLeast",
                    position: (73, 33),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "2.4pre",
                       position: (73, 47),
                      },
                     ],
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "--option experimental-features nix-command",
                     position: (73, 57),
                    },
                   ],
                  },
                 ],
                },
               },
               Raw {
                content: " \\\n  |& sed -e 's/^warning:/error:/' \\\n  | (! grep ",
                position: (73, 101),
               },
               Raw {
                content: "'",
                position: (75, 23),
               },
               Expression {
                expression: IfThenElse {
                 predicate: PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (75, 29),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "checkConfig",
                     position: (75, 33),
                    },
                   ],
                  },
                  default: None,
                 },
                 then: String {
                  parts: [
                   Raw {
                    content: "^error:",
                    position: (75, 51),
                   },
                  ],
                 },
                 else_: String {
                  parts: [
                   Raw {
                    content: "^error: unknown setting",
                    position: (75, 66),
                   },
                  ],
                 },
                 position: (75, 26),
                },
               },
               Raw {
                content: "')\nset -o pipefail\n",
                position: (75, 91),
               },
              ],
             },
             position: (63, 9),
            },
           ),
          ],
          recursive: false,
          position: (53, 24),
         },
        ],
       },
       position: (34, 5),
      },
      position: (33, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "legacyConfMappings",
        position: (80, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "useSandbox",
           position: (81, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "sandbox",
           position: (81, 19),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "buildCores",
           position: (82, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "cores",
           position: (82, 19),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "maxJobs",
           position: (83, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "max-jobs",
           position: (83, 16),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "sandboxPaths",
           position: (84, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "extra-sandbox-paths",
           position: (84, 21),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "binaryCaches",
           position: (85, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "substituters",
           position: (85, 21),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "trustedBinaryCaches",
           position: (86, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "trusted-substituters",
           position: (86, 28),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "binaryCachePublicKeys",
           position: (87, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "trusted-public-keys",
           position: (87, 30),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "autoOptimiseStore",
           position: (88, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "auto-optimise-store",
           position: (88, 26),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "requireSignedBinaryCaches",
           position: (89, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "require-sigs",
           position: (89, 34),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "trustedUsers",
           position: (90, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "trusted-users",
           position: (90, 21),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "allowedUsers",
           position: (91, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "allowed-users",
           position: (91, 21),
          },
         ],
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "systemFeatures",
           position: (92, 5),
          },
         ],
        },
        String {
         parts: [
          Raw {
           content: "system-features",
           position: (92, 23),
          },
         ],
        },
       ),
      ],
      recursive: false,
      position: (80, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "semanticConfType",
        position: (95, 3),
       },
      ],
     },
     With {
      expression: Variable {
       identifier: "types",
       position: (95, 27),
      },
      target: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "confAtom",
            position: (97, 7),
           },
          ],
         },
         BinaryOperation {
          operator: Update,
          operands: [
           FunctionApplication {
            function: Variable {
             identifier: "nullOr",
             position: (97, 18),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "oneOf",
               position: (98, 10),
              },
              arguments: [
               List {
                elements: [
                 Variable {
                  identifier: "bool",
                  position: (99, 11),
                 },
                 Variable {
                  identifier: "int",
                  position: (100, 11),
                 },
                 Variable {
                  identifier: "float",
                  position: (101, 11),
                 },
                 Variable {
                  identifier: "str",
                  position: (102, 11),
                 },
                 Variable {
                  identifier: "path",
                  position: (103, 11),
                 },
                 Variable {
                  identifier: "package",
                  position: (104, 11),
                 },
                ],
                position: (98, 16),
               },
              ],
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (106, 9),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Nix config atom (null, bool, int, float, str, path or package)",
                 position: (106, 24),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (105, 15),
           },
          ],
          position: (105, 12),
         },
        ),
       ],
       target: FunctionApplication {
        function: Variable {
         identifier: "attrsOf",
         position: (109, 5),
        },
        arguments: [
         FunctionApplication {
          function: Variable {
           identifier: "either",
           position: (109, 14),
          },
          arguments: [
           Variable {
            identifier: "confAtom",
            position: (109, 21),
           },
           FunctionApplication {
            function: Variable {
             identifier: "listOf",
             position: (109, 31),
            },
            arguments: [
             Variable {
              identifier: "confAtom",
              position: (109, 38),
             },
            ],
           },
          ],
         },
        ],
       },
       position: (96, 5),
      },
      position: (95, 22),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (114, 3),
        },
       ],
      },
      BinaryOperation {
       operator: Concatenation,
       operands: [
        List {
         elements: [
          FunctionApplication {
           function: Variable {
            identifier: "mkRenamedOptionModule",
            position: (115, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (115, 31),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "useChroot",
                 position: (115, 37),
                },
               ],
              },
             ],
             position: (115, 28),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (115, 53),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "useSandbox",
                 position: (115, 59),
                },
               ],
              },
             ],
             position: (115, 50),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkRenamedOptionModule",
            position: (116, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (116, 31),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "chrootDirs",
                 position: (116, 37),
                },
               ],
              },
             ],
             position: (116, 28),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (116, 54),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "sandboxPaths",
                 position: (116, 60),
                },
               ],
              },
             ],
             position: (116, 51),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkRenamedOptionModule",
            position: (117, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (117, 31),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "daemonIONiceLevel",
                 position: (117, 37),
                },
               ],
              },
             ],
             position: (117, 28),
            },
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (117, 61),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "daemonIOSchedPriority",
                 position: (117, 67),
                },
               ],
              },
             ],
             position: (117, 58),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkRemovedOptionModule",
            position: (118, 6),
           },
           arguments: [
            List {
             elements: [
              String {
               parts: [
                Raw {
                 content: "nix",
                 position: (118, 31),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "daemonNiceLevel",
                 position: (118, 37),
                },
               ],
              },
             ],
             position: (118, 28),
            },
            String {
             parts: [
              Raw {
               content: "Consider nix.daemonCPUSchedPolicy instead.",
               position: (118, 57),
              },
             ],
            },
           ],
          },
         ],
         position: (114, 13),
        },
        FunctionApplication {
         function: Variable {
          identifier: "mapAttrsToList",
          position: (119, 8),
         },
         arguments: [
          Function {
           argument: Some(
            "oldConf",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "newConf",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: FunctionApplication {
             function: Variable {
              identifier: "mkRenamedOptionModule",
              position: (119, 42),
             },
             arguments: [
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "nix",
                   position: (119, 67),
                  },
                 ],
                },
                Variable {
                 identifier: "oldConf",
                 position: (119, 72),
                },
               ],
               position: (119, 64),
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "nix",
                   position: (119, 85),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "settings",
                   position: (119, 91),
                  },
                 ],
                },
                Variable {
                 identifier: "newConf",
                 position: (119, 101),
                },
               ],
               position: (119, 82),
              },
             ],
            },
            position: (119, 33),
           },
           position: (119, 24),
          },
          Variable {
           identifier: "legacyConfMappings",
           position: (119, 112),
          },
         ],
        },
       ],
       position: (119, 5),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (123, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "nix",
            position: (125, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (127, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (127, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (128, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (128, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (128, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (129, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (129, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (130, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable Nix.\nDisabling Nix makes the system hard to modify and the Nix programs and configuration will not be made available by NixOS itself.\n",
                    position: (131, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (127, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (136, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (136, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (137, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (137, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (137, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (138, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (138, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "nix",
                     position: (138, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (139, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (139, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.nix",
                      position: (139, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (140, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option specifies the Nix package instance to use throughout the system.\n",
                    position: (141, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (136, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "distributedBuilds",
               position: (145, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (145, 27),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (146, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (146, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (146, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (147, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (147, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (148, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to distribute builds to the machines listed in\n<option>nix.buildMachines</option>.\n",
                    position: (149, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (145, 36),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "daemonCPUSchedPolicy",
               position: (154, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (154, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (155, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (155, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (155, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "other",
                        position: (155, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "batch",
                        position: (155, 38),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "idle",
                        position: (155, 46),
                       },
                      ],
                     },
                    ],
                    position: (155, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (156, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "other",
                    position: (156, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (157, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "batch",
                    position: (157, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (158, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Nix daemon process CPU scheduling policy. This policy propagates to\nbuild processes. <literal>other</literal> is the default scheduling\npolicy for regular tasks. The <literal>batch</literal> policy is\nsimilar to <literal>other</literal>, but optimised for\nnon-interactive tasks. <literal>idle</literal> is for extremely\nlow-priority tasks that should only be run when no other task\nrequires CPU time.\n\nPlease note that while using the <literal>idle</literal> policy may\ngreatly improve responsiveness of a system performing expensive\nbuilds, it may also slow down and potentially starve crucial\nconfiguration updates during load.\n\n<literal>idle</literal> may therefore be a sensible policy for\nsystems that experience only intermittent phases of high CPU load,\nsuch as desktop or portable computers used interactively. Other\nsystems should use the <literal>other</literal> or\n<literal>batch</literal> policy instead.\n\nFor more fine-grained resource control, please refer to\n<citerefentry><refentrytitle>systemd.resource-control\n</refentrytitle><manvolnum>5</manvolnum></citerefentry> and adjust\n<option>systemd.services.nix-daemon</option> directly.\n",
                    position: (159, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (154, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "daemonIOSchedClass",
               position: (185, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (185, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (186, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (186, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (186, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "best-effort",
                        position: (186, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "idle",
                        position: (186, 44),
                       },
                      ],
                     },
                    ],
                    position: (186, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (187, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "best-effort",
                    position: (187, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (188, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "idle",
                    position: (188, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (189, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Nix daemon process I/O scheduling class. This class propagates to\nbuild processes. <literal>best-effort</literal> is the default\nclass for regular tasks. The <literal>idle</literal> class is for\nextremely low-priority tasks that should only perform I/O when no\nother task does.\n\nPlease note that while using the <literal>idle</literal> scheduling\nclass can improve responsiveness of a system performing expensive\nbuilds, it might also slow down or starve crucial configuration\nupdates during load.\n\n<literal>idle</literal> may therefore be a sensible class for\nsystems that experience only intermittent phases of high I/O load,\nsuch as desktop or portable computers used interactively. Other\nsystems should use the <literal>best-effort</literal> class.\n",
                    position: (190, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (185, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "daemonIOSchedPriority",
               position: (208, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (208, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (209, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (209, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (209, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (210, 9),
                   },
                  ],
                 },
                 Int {
                  value: 0,
                  position: (210, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (211, 9),
                   },
                  ],
                 },
                 Int {
                  value: 1,
                  position: (211, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (212, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Nix daemon process I/O scheduling priority. This priority propagates\nto build processes. The supported priorities depend on the\nscheduling policy: With idle, priorities are not used in scheduling\ndecisions. best-effort supports values in the range 0 (high) to 7\n(low).\n",
                    position: (213, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (208, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "buildMachines",
               position: (221, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (221, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (222, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (222, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (222, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (222, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "submodule",
                        position: (222, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "options",
                           position: (223, 11),
                          },
                         ],
                        },
                        Map {
                         bindings: [
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "hostName",
                              position: (224, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (224, 24),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (225, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (225, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (225, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (226, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "nixbuilder.example.org",
                                   position: (226, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (227, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The hostname of the build machine.\n",
                                   position: (228, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (224, 33),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "system",
                              position: (231, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (231, 22),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (232, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (232, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (232, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (232, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (232, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (233, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (233, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (234, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "x86_64-linux",
                                   position: (234, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (235, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The system type the build machine can execute derivations on.\nEither this attribute or <varname>systems</varname> must be\npresent, where <varname>system</varname> takes precedence if\nboth are set.\n",
                                   position: (236, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (231, 31),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "systems",
                              position: (242, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (242, 23),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (243, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (243, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "listOf",
                                     position: (243, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (243, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (243, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (244, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [],
                                 position: (244, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (245, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "x86_64-linux",
                                     position: (245, 28),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "aarch64-linux",
                                     position: (245, 43),
                                    },
                                   ],
                                  },
                                 ],
                                 position: (245, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (246, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The system types the build machine can execute derivations on.\nEither this attribute or <varname>system</varname> must be\npresent, where <varname>system</varname> takes precedence if\nboth are set.\n",
                                   position: (247, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (242, 32),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "sshUser",
                              position: (253, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (253, 23),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (254, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (254, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (254, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (254, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (254, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (255, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (255, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (256, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "builder",
                                   position: (256, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (257, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The username to log in as on the remote host. This user must be\nable to log in and run nix commands non-interactively. It must\nalso be privileged to build derivations, so must be included in\n<option>nix.settings.trusted-users</option>.\n",
                                   position: (258, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (253, 32),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "sshKey",
                              position: (264, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (264, 22),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (265, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (265, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (265, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (265, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (265, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (266, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (266, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (267, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "/root/.ssh/id_buildhost_builduser",
                                   position: (267, 26),
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (268, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The path to the SSH private key with which to authenticate on\nthe build machine. The private key must not have a passphrase.\nIf null, the building user (root on NixOS machines) must have an\nappropriate ssh configuration to log in non-interactively.\n\nNote that for security reasons, this path must point to a file\nin the local filesystem, *not* to the nix store.\n",
                                   position: (269, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (264, 31),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "maxJobs",
                              position: (278, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (278, 23),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (279, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (279, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "int",
                                    position: (279, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (280, 15),
                                  },
                                 ],
                                },
                                Int {
                                 value: 1,
                                 position: (280, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (281, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The number of concurrent jobs the build machine supports. The\nbuild machine will enforce its own limits, but this allows hydra\nto schedule better since there is no work-stealing between build\nmachines.\n",
                                   position: (282, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (278, 32),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "speedFactor",
                              position: (288, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (288, 27),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (289, 15),
                                  },
                                 ],
                                },
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (289, 22),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "int",
                                    position: (289, 28),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (290, 15),
                                  },
                                 ],
                                },
                                Int {
                                 value: 1,
                                 position: (290, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (291, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The relative speed of this builder. This is an arbitrary integer\nthat indicates the speed of this builder, relative to other\nbuilders. Higher is faster.\n",
                                   position: (292, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (288, 36),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "mandatoryFeatures",
                              position: (297, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (297, 33),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (298, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (298, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "listOf",
                                     position: (298, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (298, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (298, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (299, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [],
                                 position: (299, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (300, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "big-parallel",
                                     position: (300, 28),
                                    },
                                   ],
                                  },
                                 ],
                                 position: (300, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (301, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "A list of features mandatory for this builder. The builder will\nbe ignored for derivations that don't require all features in\nthis list. All mandatory features are automatically included in\n<varname>supportedFeatures</varname>.\n",
                                   position: (302, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (297, 42),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "supportedFeatures",
                              position: (308, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (308, 33),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (309, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (309, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "listOf",
                                     position: (309, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (309, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (309, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (310, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [],
                                 position: (310, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "example",
                                   position: (311, 15),
                                  },
                                 ],
                                },
                                List {
                                 elements: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "kvm",
                                     position: (311, 28),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "big-parallel",
                                     position: (311, 34),
                                    },
                                   ],
                                  },
                                 ],
                                 position: (311, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (312, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "A list of features supported by this builder. The builder will\nbe ignored for derivations that require features not in this\nlist.\n",
                                   position: (313, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (308, 42),
                             },
                            ],
                           },
                          ),
                          KeyValue(
                           AttributePath {
                            attributes: [
                             Raw {
                              content: "publicHostKey",
                              position: (318, 13),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "mkOption",
                             position: (318, 29),
                            },
                            arguments: [
                             Map {
                              bindings: [
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "type",
                                   position: (319, 15),
                                  },
                                 ],
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (319, 22),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "nullOr",
                                     position: (319, 28),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (319, 35),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "str",
                                      position: (319, 41),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "default",
                                   position: (320, 15),
                                  },
                                 ],
                                },
                                Variable {
                                 identifier: "null",
                                 position: (320, 25),
                                },
                               ),
                               KeyValue(
                                AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "description",
                                   position: (321, 15),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "The (base64-encoded) public host key of this builder. The field\nis calculated via <command>base64 -w0 /etc/ssh/ssh_host_type_key.pub</command>.\nIf null, SSH will use its regular known-hosts file when connecting.\n",
                                   position: (322, 1),
                                  },
                                 ],
                                },
                               ),
                              ],
                              recursive: false,
                              position: (318, 38),
                             },
                            ],
                           },
                          ),
                         ],
                         recursive: false,
                         position: (223, 21),
                        },
                       ),
                      ],
                      recursive: false,
                      position: (222, 46),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (329, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (329, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (330, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option lists the machines to be used if distributed builds are\nenabled (see <option>nix.distributedBuilds</option>).\nNix will perform derivations on those machines via SSH by copying the\ninputs to the Nix store on the remote machine, starting the build,\nthen copying the output back to the local Nix store.\n",
                    position: (331, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (221, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "envVars",
               position: (340, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (340, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (341, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (341, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (341, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "internal",
                    position: (342, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (342, 20),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (343, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (343, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (344, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Environment variables used by Nix.",
                    position: (344, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (340, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nrBuildUsers",
               position: (347, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (347, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (348, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (348, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (348, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (349, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Number of <literal>nixbld</literal> user accounts created to\nperform secure concurrent builds.  If you receive an error\nmessage saying that “all build users are currently in use”,\nyou should increase this value.\n",
                    position: (350, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (347, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "readOnlyStore",
               position: (357, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (357, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (358, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (358, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (358, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (359, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (359, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (360, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If set, NixOS will enforce the immutability of the Nix store\nby making <filename>/nix/store</filename> a read-only bind\nmount.  Nix will automatically make the store writable when\nneeded.\n",
                    position: (361, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (357, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nixPath",
               position: (368, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (368, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (369, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (369, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (369, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (369, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (369, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (370, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "nixpkgs=/nix/var/nix/profiles/per-user/root/channels/nixos",
                      position: (371, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "nixos-config=/etc/nixos/configuration.nix",
                      position: (372, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "/nix/var/nix/profiles/per-user/root/channels",
                      position: (373, 12),
                     },
                    ],
                   },
                  ],
                  position: (370, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (375, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The default Nix expression search path, used by the Nix\nevaluator to look up paths enclosed in angle brackets\n(e.g. <literal>&lt;nixpkgs&gt;</literal>).\n",
                    position: (376, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (368, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "checkConfig",
               position: (382, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (382, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (383, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (383, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (383, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (384, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (384, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (385, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If enabled (the default), checks for data type mismatches and that Nix\ncan parse the generated nix.conf.\n",
                    position: (386, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (382, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "registry",
               position: (391, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (391, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (392, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (392, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (392, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (392, 31),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "submodule",
                        position: (392, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     LetIn {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "referenceAttrs",
                           position: (394, 13),
                          },
                         ],
                        },
                        With {
                         expression: Variable {
                          identifier: "types",
                          position: (394, 35),
                         },
                         target: FunctionApplication {
                          function: Variable {
                           identifier: "attrsOf",
                           position: (394, 42),
                          },
                          arguments: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "oneOf",
                             position: (394, 51),
                            },
                            arguments: [
                             List {
                              elements: [
                               Variable {
                                identifier: "str",
                                position: (395, 15),
                               },
                               Variable {
                                identifier: "int",
                                position: (396, 15),
                               },
                               Variable {
                                identifier: "bool",
                                position: (397, 15),
                               },
                               Variable {
                                identifier: "package",
                                position: (398, 15),
                               },
                              ],
                              position: (394, 57),
                             },
                            ],
                           },
                          ],
                         },
                         position: (394, 30),
                        },
                       ),
                      ],
                      target: Function {
                       argument: None,
                       arguments: FunctionArguments {
                        arguments: [
                         FunctionArgument {
                          identifier: "name",
                          default: None,
                         },
                         FunctionArgument {
                          identifier: "config",
                          default: None,
                         },
                        ],
                        ellipsis: true,
                       },
                       definition: Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "options",
                             position: (403, 13),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "from",
                                position: (404, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "mkOption",
                               position: (404, 22),
                              },
                              arguments: [
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "type",
                                     position: (405, 17),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "referenceAttrs",
                                   position: (405, 24),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "example",
                                     position: (406, 17),
                                    },
                                   ],
                                  },
                                  Map {
                                   bindings: [
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "type",
                                        position: (406, 29),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "indirect",
                                        position: (406, 37),
                                       },
                                      ],
                                     },
                                    ),
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "id",
                                        position: (406, 48),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "nixpkgs",
                                        position: (406, 54),
                                       },
                                      ],
                                     },
                                    ),
                                   ],
                                   recursive: false,
                                   position: (406, 27),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "description",
                                     position: (407, 17),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "The flake reference to be rewritten.",
                                     position: (407, 32),
                                    },
                                   ],
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (404, 31),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "to",
                                position: (409, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "mkOption",
                               position: (409, 20),
                              },
                              arguments: [
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "type",
                                     position: (410, 17),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "referenceAttrs",
                                   position: (410, 24),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "example",
                                     position: (411, 17),
                                    },
                                   ],
                                  },
                                  Map {
                                   bindings: [
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "type",
                                        position: (411, 29),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "github",
                                        position: (411, 37),
                                       },
                                      ],
                                     },
                                    ),
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "owner",
                                        position: (411, 46),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "my-org",
                                        position: (411, 55),
                                       },
                                      ],
                                     },
                                    ),
                                    KeyValue(
                                     AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "repo",
                                        position: (411, 64),
                                       },
                                      ],
                                     },
                                     String {
                                      parts: [
                                       Raw {
                                        content: "my-nixpkgs",
                                        position: (411, 72),
                                       },
                                      ],
                                     },
                                    ),
                                   ],
                                   recursive: false,
                                   position: (411, 27),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "description",
                                     position: (412, 17),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "The flake reference <option>from></option> is rewritten to.",
                                     position: (412, 32),
                                    },
                                   ],
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (409, 29),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "flake",
                                position: (414, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "mkOption",
                               position: (414, 23),
                              },
                              arguments: [
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "type",
                                     position: (415, 17),
                                    },
                                   ],
                                  },
                                  FunctionApplication {
                                   function: PropertyAccess {
                                    expression: Variable {
                                     identifier: "types",
                                     position: (415, 24),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "nullOr",
                                       position: (415, 30),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   arguments: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "types",
                                      position: (415, 37),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "attrs",
                                        position: (415, 43),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ],
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "default",
                                     position: (416, 17),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (416, 27),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "example",
                                     position: (417, 17),
                                    },
                                   ],
                                  },
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "literalExpression",
                                    position: (417, 27),
                                   },
                                   arguments: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "nixpkgs",
                                       position: (417, 46),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "description",
                                     position: (418, 17),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "The flake input <option>from></option> is rewritten to.\n",
                                     position: (419, 1),
                                    },
                                   ],
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (414, 32),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "exact",
                                position: (422, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "mkOption",
                               position: (422, 23),
                              },
                              arguments: [
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "type",
                                     position: (423, 17),
                                    },
                                   ],
                                  },
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "types",
                                    position: (423, 24),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "bool",
                                      position: (423, 30),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "default",
                                     position: (424, 17),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "true",
                                   position: (424, 27),
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "description",
                                     position: (425, 17),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "Whether the <option>from</option> reference needs to match exactly. If set,\na <option>from</option> reference like <literal>nixpkgs</literal> does not\nmatch with a reference like <literal>nixpkgs/nixos-20.03</literal>.\n",
                                     position: (426, 1),
                                    },
                                   ],
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (422, 32),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (403, 23),
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "config",
                             position: (432, 13),
                            },
                           ],
                          },
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "from",
                                position: (433, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "mkDefault",
                               position: (433, 22),
                              },
                              arguments: [
                               Map {
                                bindings: [
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "type",
                                     position: (433, 34),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "indirect",
                                     position: (433, 42),
                                    },
                                   ],
                                  },
                                 ),
                                 KeyValue(
                                  AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "id",
                                     position: (433, 53),
                                    },
                                   ],
                                  },
                                  Variable {
                                   identifier: "name",
                                   position: (433, 58),
                                  },
                                 ),
                                ],
                                recursive: false,
                                position: (433, 32),
                               },
                              ],
                             },
                            ),
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "to",
                                position: (434, 15),
                               },
                              ],
                             },
                             FunctionApplication {
                              function: Variable {
                               identifier: "mkIf",
                               position: (434, 20),
                              },
                              arguments: [
                               BinaryOperation {
                                operator: NotEqualTo,
                                operands: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "config",
                                   position: (434, 26),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "flake",
                                     position: (434, 33),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 Variable {
                                  identifier: "null",
                                  position: (434, 42),
                                 },
                                ],
                                position: (434, 39),
                               },
                               BinaryOperation {
                                operator: Update,
                                operands: [
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "mkDefault",
                                   position: (434, 49),
                                  },
                                  arguments: [
                                   Map {
                                    bindings: [
                                     KeyValue(
                                      AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "type",
                                         position: (436, 19),
                                        },
                                       ],
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "path",
                                         position: (436, 27),
                                        },
                                       ],
                                      },
                                     ),
                                     KeyValue(
                                      AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "path",
                                         position: (437, 19),
                                        },
                                       ],
                                      },
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "config",
                                        position: (437, 26),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "flake",
                                          position: (437, 33),
                                         },
                                         Raw {
                                          content: "outPath",
                                          position: (437, 39),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                     ),
                                    ],
                                    recursive: false,
                                    position: (435, 17),
                                   },
                                  ],
                                 },
                                 FunctionApplication {
                                  function: Variable {
                                   identifier: "filterAttrs",
                                   position: (438, 22),
                                  },
                                  arguments: [
                                   Function {
                                    argument: Some(
                                     "n",
                                    ),
                                    arguments: FunctionArguments {
                                     arguments: [],
                                     ellipsis: false,
                                    },
                                    definition: Function {
                                     argument: Some(
                                      "_",
                                     ),
                                     arguments: FunctionArguments {
                                      arguments: [],
                                      ellipsis: false,
                                     },
                                     definition: BinaryOperation {
                                      operator: LogicalOr,
                                      operands: [
                                       BinaryOperation {
                                        operator: LogicalOr,
                                        operands: [
                                         BinaryOperation {
                                          operator: LogicalOr,
                                          operands: [
                                           BinaryOperation {
                                            operator: EqualTo,
                                            operands: [
                                             Variable {
                                              identifier: "n",
                                              position: (439, 24),
                                             },
                                             String {
                                              parts: [
                                               Raw {
                                                content: "lastModified",
                                                position: (439, 30),
                                               },
                                              ],
                                             },
                                            ],
                                            position: (439, 26),
                                           },
                                           BinaryOperation {
                                            operator: EqualTo,
                                            operands: [
                                             Variable {
                                              identifier: "n",
                                              position: (439, 47),
                                             },
                                             String {
                                              parts: [
                                               Raw {
                                                content: "rev",
                                                position: (439, 53),
                                               },
                                              ],
                                             },
                                            ],
                                            position: (439, 49),
                                           },
                                          ],
                                          position: (439, 44),
                                         },
                                         BinaryOperation {
                                          operator: EqualTo,
                                          operands: [
                                           Variable {
                                            identifier: "n",
                                            position: (439, 61),
                                           },
                                           String {
                                            parts: [
                                             Raw {
                                              content: "revCount",
                                              position: (439, 67),
                                             },
                                            ],
                                           },
                                          ],
                                          position: (439, 63),
                                         },
                                        ],
                                        position: (439, 58),
                                       },
                                       BinaryOperation {
                                        operator: EqualTo,
                                        operands: [
                                         Variable {
                                          identifier: "n",
                                          position: (439, 80),
                                         },
                                         String {
                                          parts: [
                                           Raw {
                                            content: "narHash",
                                            position: (439, 86),
                                           },
                                          ],
                                         },
                                        ],
                                        position: (439, 82),
                                       },
                                      ],
                                      position: (439, 77),
                                     },
                                     position: (439, 21),
                                    },
                                    position: (439, 18),
                                   },
                                   PropertyAccess {
                                    expression: Variable {
                                     identifier: "config",
                                     position: (440, 17),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "flake",
                                       position: (440, 24),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  ],
                                 },
                                ],
                                position: (438, 19),
                               },
                              ],
                             },
                            ),
                           ],
                           recursive: false,
                           position: (432, 22),
                          },
                         ),
                        ],
                        recursive: false,
                        position: (402, 11),
                       },
                       position: (401, 11),
                      },
                      position: (393, 11),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (444, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (444, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (445, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A system-wide flake registry.\n",
                    position: (446, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (391, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraOptions",
               position: (450, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (450, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (451, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (451, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (451, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (452, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (453, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "keep-outputs = true\nkeep-derivations = true\n",
                    position: (454, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (457, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Additional text appended to <filename>nix.conf</filename>.",
                    position: (457, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (450, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "settings",
               position: (460, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (460, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (461, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (461, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "submodule",
                      position: (461, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "freeformType",
                         position: (462, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "semanticConfType",
                       position: (462, 26),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "options",
                         position: (464, 11),
                        },
                       ],
                      },
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "max-jobs",
                            position: (465, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (465, 24),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (466, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (466, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "either",
                                   position: (466, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (466, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "int",
                                    position: (466, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (466, 46),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "enum",
                                     position: (466, 52),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  List {
                                   elements: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "auto",
                                       position: (466, 60),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (466, 57),
                                  },
                                 ],
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (467, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "auto",
                                 position: (467, 26),
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (468, 15),
                                },
                               ],
                              },
                              Int {
                               value: 64,
                               position: (468, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (469, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "This option defines the maximum number of jobs that Nix will try to\nbuild in parallel. The default is auto, which means it will use all\navailable logical cores. It is recommend to set it to the total\nnumber of logical cores in your system (e.g., 16 for two CPUs with 4\ncores each and hyper-threading).\n",
                                 position: (470, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (465, 33),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "auto-optimise-store",
                            position: (478, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (478, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (479, 15),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (479, 22),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (479, 28),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (480, 15),
                                },
                               ],
                              },
                              Variable {
                               identifier: "false",
                               position: (480, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (481, 15),
                                },
                               ],
                              },
                              Variable {
                               identifier: "true",
                               position: (481, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (482, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "If set to true, Nix automatically detects files in the store that have\nidentical contents, and replaces them with hard links to a single copy.\nThis saves disk space. If set to false (the default), you can still run\nnix-store --optimise to get rid of duplicate files.\n",
                                 position: (483, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (478, 44),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "cores",
                            position: (490, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (490, 21),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (491, 15),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (491, 22),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "int",
                                  position: (491, 28),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (492, 15),
                                },
                               ],
                              },
                              Int {
                               value: 0,
                               position: (492, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (493, 15),
                                },
                               ],
                              },
                              Int {
                               value: 64,
                               position: (493, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (494, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "This option defines the maximum number of concurrent tasks during\none build. It affects, e.g., -j option for make.\nThe special value 0 means that the builder should use all\navailable CPU cores in the system. Some builds may become\nnon-deterministic with this option; use with care! Packages will\nonly be affected if enableParallelBuilding is set for them.\n",
                                 position: (495, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (490, 30),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "sandbox",
                            position: (504, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (504, 23),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (505, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (505, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "either",
                                   position: (505, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (505, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "bool",
                                    position: (505, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                FunctionApplication {
                                 function: PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (505, 47),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "enum",
                                     position: (505, 53),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 arguments: [
                                  List {
                                   elements: [
                                    String {
                                     parts: [
                                      Raw {
                                       content: "relaxed",
                                       position: (505, 61),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (505, 58),
                                  },
                                 ],
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (506, 15),
                                },
                               ],
                              },
                              Variable {
                               identifier: "true",
                               position: (506, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (507, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "If set, Nix will perform builds in a sandboxed environment that it\nwill set up automatically for each build. This prevents impurities\nin builds by disallowing access to dependencies outside of the Nix\nstore by using network and mount namespaces in a chroot environment.\nThis is enabled by default even though it has a possible performance\nimpact due to the initial setup time of a sandbox for each build. It\ndoesn't affect derivation hashes, so changing this option will not\ntrigger a rebuild of packages.\n",
                                 position: (508, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (504, 32),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "extra-sandbox-paths",
                            position: (519, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (519, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (520, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (520, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (520, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (520, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (520, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (521, 15),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (521, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (522, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "/dev",
                                   position: (522, 28),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "/proc",
                                   position: (522, 35),
                                  },
                                 ],
                                },
                               ],
                               position: (522, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (523, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "Directories from the host filesystem to be included\nin the sandbox.\n",
                                 position: (524, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (519, 44),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "substituters",
                            position: (529, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (529, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (530, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (530, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (530, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (530, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (530, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (531, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "List of binary cache URLs used to obtain pre-built binaries\nof Nix packages.\n\nBy default https://cache.nixos.org/ is added.\n",
                                 position: (532, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (529, 37),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "trusted-substituters",
                            position: (539, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (539, 36),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (540, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (540, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (540, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (540, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (540, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (541, 15),
                                },
                               ],
                              },
                              List {
                               elements: [],
                               position: (541, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (542, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "https://hydra.nixos.org/",
                                   position: (542, 28),
                                  },
                                 ],
                                },
                               ],
                               position: (542, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (543, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "List of binary cache URLs that non-root users can use (in\naddition to those specified using\n<option>nix.settings.substituters</option>) by passing\n<literal>--option binary-caches</literal> to Nix commands.\n",
                                 position: (544, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (539, 45),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "require-sigs",
                            position: (551, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (551, 28),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (552, 15),
                                },
                               ],
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "types",
                                position: (552, 22),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "bool",
                                  position: (552, 28),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (553, 15),
                                },
                               ],
                              },
                              Variable {
                               identifier: "true",
                               position: (553, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (554, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "If enabled (the default), Nix will only download binaries from binary caches if\nthey are cryptographically signed with any of the keys listed in\n<option>nix.settings.trusted-public-keys</option>. If disabled, signatures are neither\nrequired nor checked, so it's strongly recommended that you use only\ntrustworthy caches and https to prevent man-in-the-middle attacks.\n",
                                 position: (555, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (551, 37),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "trusted-public-keys",
                            position: (563, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (563, 35),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (564, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (564, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (564, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (564, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (564, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (565, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "hydra.nixos.org-1:CNHJZBh9K4tP3EKF6FkkgeVYsS3ohTl+oS0Qa8bezVs=",
                                   position: (565, 28),
                                  },
                                 ],
                                },
                               ],
                               position: (565, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (566, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "List of public keys used to sign binary caches. If\n<option>nix.settings.trusted-public-keys</option> is enabled,\nthen Nix will use a binary from a binary cache if and only\nif it is signed by <emphasis>any</emphasis> of the keys\nlisted here. By default, only the key for\n<uri>cache.nixos.org</uri> is included.\n",
                                 position: (567, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (563, 44),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "trusted-users",
                            position: (576, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (576, 29),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (577, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (577, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (577, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (577, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (577, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (578, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "root",
                                   position: (578, 28),
                                  },
                                 ],
                                },
                               ],
                               position: (578, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (579, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "root",
                                   position: (579, 28),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "alice",
                                   position: (579, 35),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "@wheel",
                                   position: (579, 43),
                                  },
                                 ],
                                },
                               ],
                               position: (579, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (580, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "A list of names of users that have additional rights when\nconnecting to the Nix daemon, such as the ability to specify\nadditional binary caches, or to import unsigned NARs. You\ncan also specify groups by prefixing them with\n<literal>@</literal>; for instance,\n<literal>@wheel</literal> means all users in the wheel\ngroup.\n",
                                 position: (581, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (576, 38),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "system-features",
                            position: (591, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (591, 31),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (592, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (592, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (592, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (592, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (592, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (593, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "kvm",
                                   position: (593, 28),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "big-parallel",
                                   position: (593, 34),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "gccarch-skylake",
                                   position: (593, 49),
                                  },
                                 ],
                                },
                               ],
                               position: (593, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (594, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "The set of features supported by the machine. Derivations\ncan express dependencies on system features through the\n<literal>requiredSystemFeatures</literal> attribute.\n\nBy default, pseudo-features <literal>nixos-test</literal>, <literal>benchmark</literal>,\nand <literal>big-parallel</literal> used in Nixpkgs are set, <literal>kvm</literal>\nis also included in it is avaliable.\n",
                                 position: (595, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (591, 40),
                           },
                          ],
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "allowed-users",
                            position: (605, 13),
                           },
                          ],
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "mkOption",
                           position: (605, 29),
                          },
                          arguments: [
                           Map {
                            bindings: [
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "type",
                                 position: (606, 15),
                                },
                               ],
                              },
                              FunctionApplication {
                               function: PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (606, 22),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "listOf",
                                   position: (606, 28),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               arguments: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (606, 35),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "str",
                                    position: (606, 41),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               ],
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "default",
                                 position: (607, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "*",
                                   position: (607, 28),
                                  },
                                 ],
                                },
                               ],
                               position: (607, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "example",
                                 position: (608, 15),
                                },
                               ],
                              },
                              List {
                               elements: [
                                String {
                                 parts: [
                                  Raw {
                                   content: "@wheel",
                                   position: (608, 28),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "@builders",
                                   position: (608, 37),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "alice",
                                   position: (608, 49),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "bob",
                                   position: (608, 57),
                                  },
                                 ],
                                },
                               ],
                               position: (608, 25),
                              },
                             ),
                             KeyValue(
                              AttributePath {
                               attributes: [
                                Raw {
                                 content: "description",
                                 position: (609, 15),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "A list of names of users (separated by whitespace) that are\nallowed to connect to the Nix daemon. As with\n<option>nix.settings.trusted-users</option>, you can specify groups by\nprefixing them with <literal>@</literal>. Also, you can\nallow all users by specifying <literal>*</literal>. The\ndefault is <literal>*</literal>. Note that trusted users are\nalways allowed to connect.\n",
                                 position: (610, 1),
                                },
                               ],
                              },
                             ),
                            ],
                            recursive: false,
                            position: (605, 38),
                           },
                          ],
                         },
                        ),
                       ],
                       recursive: false,
                       position: (464, 21),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (461, 32),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (621, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (621, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (622, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (622, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  use-sandbox = true;\n  show-trace = true;\n\n  system-features = [ \"big-parallel\" \"kvm\" \"recursive-nix\" ];\n  sandbox-paths = { \"/bin/sh\" = \"",
                      position: (623, 1),
                     },
                     Raw {
                      content: "$",
                      position: (628, 44),
                     },
                     Raw {
                      content: "{pkgs.busybox-sandbox-shell.out}/bin/busybox\"; };\n}\n",
                      position: (628, 47),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (631, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Configuration for Nix, see\n<link xlink:href=\"https://nixos.org/manual/nix/stable/#sec-conf-file\"/> or\n<citerefentry>\n  <refentrytitle>nix.conf</refentrytitle>\n  <manvolnum>5</manvolnum>\n</citerefentry> for avalaible options.\nThe value declared here will be translated directly to the key-value pairs Nix expects.\n</para>\n<para>\nYou can use <command>nix-instantiate --eval --strict '&lt;nixpkgs/nixos&gt;' -A config.nix.settings</command>\nto view the current value. By default it is empty.\n</para>\n<para>\nNix configurations defined under <option>nix.*</option> will be translated and applied to this\noption. In addition, configuration specified in <option>nix.extraOptions</option> which will be appended\nverbatim to the resulting config file.\n",
                    position: (632, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (460, 27),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (125, 11),
         },
        ),
       ],
       recursive: false,
       position: (123, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (656, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (656, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (656, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (656, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (657, 5),
             },
             Raw {
              content: "systemPackages",
              position: (657, 17),
             },
            ],
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             List {
              elements: [
               Variable {
                identifier: "nixPackage",
                position: (659, 9),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (660, 9),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nix-info",
                   position: (660, 14),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (658, 7),
             },
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (662, 10),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (662, 20),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "programs",
                   position: (662, 27),
                  },
                  Raw {
                   content: "bash",
                   position: (662, 36),
                  },
                  Raw {
                   content: "enableCompletion",
                   position: (662, 41),
                  },
                 ],
                },
                default: None,
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "pkgs",
                 position: (662, 59),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nix-bash-completions",
                   position: (662, 64),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            ],
            position: (662, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (664, 5),
             },
             Raw {
              content: "etc",
              position: (664, 17),
             },
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "nix/nix.conf",
                 position: (664, 22),
                },
               ],
              },
             },
             Raw {
              content: "source",
              position: (664, 36),
             },
            ],
           },
           Variable {
            identifier: "nixConf",
            position: (664, 45),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (666, 5),
             },
             Raw {
              content: "etc",
              position: (666, 17),
             },
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "nix/registry.json",
                 position: (666, 22),
                },
               ],
              },
             },
             Raw {
              content: "text",
              position: (666, 41),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (666, 48),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "toJSON",
                position: (666, 57),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "version",
                   position: (667, 7),
                  },
                 ],
                },
                Int {
                 value: 2,
                 position: (667, 17),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "flakes",
                   position: (668, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mapAttrsToList",
                  position: (668, 16),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "n",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: Function {
                    argument: Some(
                     "v",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: Map {
                     bindings: [
                      Inherit(
                       Some(
                        Variable {
                         identifier: "v",
                         position: (668, 49),
                        },
                       ),
                       [
                        Raw {
                         content: "from",
                         position: (668, 52),
                        },
                        Raw {
                         content: "to",
                         position: (668, 57),
                        },
                        Raw {
                         content: "exact",
                         position: (668, 60),
                        },
                       ],
                      ),
                     ],
                     recursive: false,
                     position: (668, 38),
                    },
                    position: (668, 35),
                   },
                   position: (668, 32),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (668, 70),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "registry",
                      position: (668, 74),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (666, 64),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (673, 5),
             },
             Raw {
              content: "etc",
              position: (673, 17),
             },
             Expression {
              expression: String {
               parts: [
                Raw {
                 content: "nix/machines",
                 position: (673, 22),
                },
               ],
              },
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkIf",
             position: (673, 38),
            },
            arguments: [
             BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (673, 44),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "buildMachines",
                   position: (673, 48),
                  },
                 ],
                },
                default: None,
               },
               List {
                elements: [],
                position: (673, 65),
               },
              ],
              position: (673, 62),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "text",
                   position: (674, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "concatMapStrings",
                  position: (675, 9),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "machine",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: BinaryOperation {
                    operator: Addition,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "concatStringsSep",
                       position: (677, 14),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: " ",
                          position: (677, 32),
                         },
                        ],
                       },
                       BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         List {
                          elements: [
                           String {
                            parts: [
                             Expression {
                              expression: FunctionApplication {
                               function: Variable {
                                identifier: "optionalString",
                                position: (678, 18),
                               },
                               arguments: [
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "machine",
                                    position: (678, 34),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "sshUser",
                                      position: (678, 42),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (678, 53),
                                  },
                                 ],
                                 position: (678, 50),
                                },
                                String {
                                 parts: [
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "machine",
                                     position: (678, 62),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "sshUser",
                                       position: (678, 70),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "@",
                                   position: (678, 78),
                                  },
                                 ],
                                },
                               ],
                              },
                             },
                             Expression {
                              expression: PropertyAccess {
                               expression: Variable {
                                identifier: "machine",
                                position: (678, 83),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "hostName",
                                  position: (678, 91),
                                 },
                                ],
                               },
                               default: None,
                              },
                             },
                            ],
                           },
                           IfThenElse {
                            predicate: BinaryOperation {
                             operator: NotEqualTo,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "machine",
                                position: (679, 19),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "system",
                                  position: (679, 27),
                                 },
                                ],
                               },
                               default: None,
                              },
                              Variable {
                               identifier: "null",
                               position: (679, 37),
                              },
                             ],
                             position: (679, 34),
                            },
                            then: PropertyAccess {
                             expression: Variable {
                              identifier: "machine",
                              position: (679, 47),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "system",
                                position: (679, 55),
                               },
                              ],
                             },
                             default: None,
                            },
                            else_: IfThenElse {
                             predicate: BinaryOperation {
                              operator: NotEqualTo,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "machine",
                                 position: (679, 70),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "systems",
                                   position: (679, 78),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               List {
                                elements: [],
                                position: (679, 89),
                               },
                              ],
                              position: (679, 86),
                             },
                             then: FunctionApplication {
                              function: Variable {
                               identifier: "concatStringsSep",
                               position: (679, 98),
                              },
                              arguments: [
                               String {
                                parts: [
                                 Raw {
                                  content: ",",
                                  position: (679, 116),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "machine",
                                 position: (679, 119),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "systems",
                                   position: (679, 127),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ],
                             },
                             else_: String {
                              parts: [
                               Raw {
                                content: "-",
                                position: (679, 141),
                               },
                              ],
                             },
                             position: (679, 67),
                            },
                            position: (679, 16),
                           },
                           IfThenElse {
                            predicate: BinaryOperation {
                             operator: NotEqualTo,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "machine",
                                position: (680, 19),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "sshKey",
                                  position: (680, 27),
                                 },
                                ],
                               },
                               default: None,
                              },
                              Variable {
                               identifier: "null",
                               position: (680, 37),
                              },
                             ],
                             position: (680, 34),
                            },
                            then: PropertyAccess {
                             expression: Variable {
                              identifier: "machine",
                              position: (680, 47),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "sshKey",
                                position: (680, 55),
                               },
                              ],
                             },
                             default: None,
                            },
                            else_: String {
                             parts: [
                              Raw {
                               content: "-",
                               position: (680, 68),
                              },
                             ],
                            },
                            position: (680, 16),
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (681, 16),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "machine",
                               position: (681, 25),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "maxJobs",
                                 position: (681, 33),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "toString",
                             position: (682, 16),
                            },
                            arguments: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "machine",
                               position: (682, 25),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "speedFactor",
                                 position: (682, 33),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "concatStringsSep",
                             position: (683, 16),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: ",",
                                position: (683, 34),
                               },
                              ],
                             },
                             BinaryOperation {
                              operator: Concatenation,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "machine",
                                 position: (683, 38),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "supportedFeatures",
                                   position: (683, 46),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "machine",
                                 position: (683, 67),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "mandatoryFeatures",
                                   position: (683, 75),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ],
                              position: (683, 64),
                             },
                            ],
                           },
                           FunctionApplication {
                            function: Variable {
                             identifier: "concatStringsSep",
                             position: (684, 16),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: ",",
                                position: (684, 34),
                               },
                              ],
                             },
                             PropertyAccess {
                              expression: Variable {
                               identifier: "machine",
                               position: (684, 37),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "mandatoryFeatures",
                                 position: (684, 45),
                                },
                               ],
                              },
                              default: None,
                             },
                            ],
                           },
                          ],
                          position: (677, 36),
                         },
                         FunctionApplication {
                          function: Variable {
                           identifier: "optional",
                           position: (686, 16),
                          },
                          arguments: [
                           FunctionApplication {
                            function: Variable {
                             identifier: "isNixAtLeast",
                             position: (686, 26),
                            },
                            arguments: [
                             String {
                              parts: [
                               Raw {
                                content: "2.4pre",
                                position: (686, 40),
                               },
                              ],
                             },
                            ],
                           },
                           IfThenElse {
                            predicate: BinaryOperation {
                             operator: NotEqualTo,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "machine",
                                position: (686, 53),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "publicHostKey",
                                  position: (686, 61),
                                 },
                                ],
                               },
                               default: None,
                              },
                              Variable {
                               identifier: "null",
                               position: (686, 78),
                              },
                             ],
                             position: (686, 75),
                            },
                            then: PropertyAccess {
                             expression: Variable {
                              identifier: "machine",
                              position: (686, 88),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "publicHostKey",
                                position: (686, 96),
                               },
                              ],
                             },
                             default: None,
                            },
                            else_: String {
                             parts: [
                              Raw {
                               content: "-",
                               position: (686, 116),
                              },
                             ],
                            },
                            position: (686, 50),
                           },
                          ],
                         },
                        ],
                        position: (686, 13),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "\n",
                        position: (687, 16),
                       },
                      ],
                     },
                    ],
                    position: (687, 13),
                   },
                   position: (676, 12),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (689, 11),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "buildMachines",
                      position: (689, 15),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (673, 70),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "assertions",
              position: (692, 5),
             },
            ],
           },
           LetIn {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "badMachine",
                 position: (693, 11),
                },
               ],
              },
              Function {
               argument: Some(
                "m",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (693, 27),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "system",
                       position: (693, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "null",
                    position: (693, 39),
                   },
                  ],
                  position: (693, 36),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "m",
                     position: (693, 47),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "systems",
                       position: (693, 49),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [],
                    position: (693, 60),
                   },
                  ],
                  position: (693, 57),
                 },
                ],
                position: (693, 44),
               },
               position: (693, 24),
              },
             ),
            ],
            target: List {
             elements: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "assertion",
                    position: (697, 11),
                   },
                  ],
                 },
                 UnaryOperation {
                  operator: Not,
                  operand: FunctionApplication {
                   function: Variable {
                    identifier: "any",
                    position: (697, 25),
                   },
                   arguments: [
                    Variable {
                     identifier: "badMachine",
                     position: (697, 29),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (697, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "buildMachines",
                        position: (697, 44),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  position: (697, 23),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "message",
                    position: (698, 11),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Addition,
                  operands: [
                   BinaryOperation {
                    operator: Addition,
                    operands: [
                     String {
                      parts: [
                       Raw {
                        content: "At least one system type (via <varname>system</varname> or\n  <varname>systems</varname>) must be set for every build machine.\n  Invalid machine specifications:\n",
                        position: (699, 1),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "      ",
                        position: (702, 17),
                       },
                      ],
                     },
                    ],
                    position: (702, 14),
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "concatStringsSep",
                     position: (703, 12),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "\n      ",
                        position: (703, 30),
                       },
                      ],
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "map",
                       position: (704, 14),
                      },
                      arguments: [
                       Function {
                        argument: Some(
                         "m",
                        ),
                        arguments: FunctionArguments {
                         arguments: [],
                         ellipsis: false,
                        },
                        definition: PropertyAccess {
                         expression: Variable {
                          identifier: "m",
                          position: (704, 22),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "hostName",
                            position: (704, 24),
                           },
                          ],
                         },
                         default: None,
                        },
                        position: (704, 19),
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "filter",
                         position: (705, 16),
                        },
                        arguments: [
                         Variable {
                          identifier: "badMachine",
                          position: (705, 24),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (705, 36),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "buildMachines",
                             position: (705, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                      ],
                     },
                    ],
                   },
                  ],
                  position: (702, 25),
                 },
                ),
               ],
               recursive: false,
               position: (696, 9),
              },
             ],
             position: (695, 7),
            },
            position: (693, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (709, 5),
             },
             Raw {
              content: "packages",
              position: (709, 13),
             },
            ],
           },
           List {
            elements: [
             Variable {
              identifier: "nixPackage",
              position: (709, 26),
             },
            ],
            position: (709, 24),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (711, 5),
             },
             Raw {
              content: "sockets",
              position: (711, 13),
             },
             Raw {
              content: "nix-daemon",
              position: (711, 21),
             },
             Raw {
              content: "wantedBy",
              position: (711, 32),
             },
            ],
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "sockets.target",
                position: (711, 46),
               },
              ],
             },
            ],
            position: (711, 43),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (713, 5),
             },
             Raw {
              content: "services",
              position: (713, 13),
             },
             Raw {
              content: "nix-daemon",
              position: (713, 22),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "path",
                 position: (715, 9),
                },
               ],
              },
              BinaryOperation {
               operator: Concatenation,
               operands: [
                List {
                 elements: [
                  Variable {
                   identifier: "nixPackage",
                   position: (715, 18),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (715, 29),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "util-linux",
                      position: (715, 34),
                     },
                    ],
                   },
                   default: None,
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (715, 45),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "programs",
                      position: (715, 52),
                     },
                     Raw {
                      content: "ssh",
                      position: (715, 61),
                     },
                     Raw {
                      content: "package",
                      position: (715, 65),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (715, 16),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionals",
                  position: (716, 14),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (716, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "distributedBuilds",
                      position: (716, 28),
                     },
                    ],
                   },
                   default: None,
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (716, 48),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "gzip",
                        position: (716, 53),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (716, 46),
                  },
                 ],
                },
               ],
               position: (716, 11),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "environment",
                 position: (718, 9),
                },
               ],
              },
              BinaryOperation {
               operator: Update,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (718, 23),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "envVars",
                    position: (718, 27),
                   },
                  ],
                 },
                 default: None,
                },
                BinaryOperation {
                 operator: Update,
                 operands: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "CURL_CA_BUNDLE",
                        position: (719, 16),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "/etc/ssl/certs/ca-certificates.crt",
                        position: (719, 34),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (719, 14),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (720, 14),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "networking",
                      position: (720, 21),
                     },
                     Raw {
                      content: "proxy",
                      position: (720, 32),
                     },
                     Raw {
                      content: "envVars",
                      position: (720, 38),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (720, 11),
                },
               ],
               position: (719, 11),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "unitConfig",
                 position: (722, 9),
                },
                Raw {
                 content: "RequiresMountsFor",
                 position: (722, 20),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/nix/store",
                 position: (722, 41),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "serviceConfig",
                 position: (724, 9),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "CPUSchedulingPolicy",
                    position: (726, 13),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (726, 35),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "daemonCPUSchedPolicy",
                     position: (726, 39),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "IOSchedulingClass",
                    position: (727, 13),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (727, 33),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "daemonIOSchedClass",
                     position: (727, 37),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "IOSchedulingPriority",
                    position: (728, 13),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (728, 36),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "daemonIOSchedPriority",
                     position: (728, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "LimitNOFILE",
                    position: (729, 13),
                   },
                  ],
                 },
                 Int {
                  value: 4096,
                  position: (729, 27),
                 },
                ),
               ],
               recursive: false,
               position: (725, 11),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "restartTriggers",
                 position: (732, 9),
                },
               ],
              },
              List {
               elements: [
                Variable {
                 identifier: "nixConf",
                 position: (732, 29),
                },
               ],
               position: (732, 27),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "stopIfChanged",
                 position: (765, 9),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (765, 25),
              },
             ),
            ],
            recursive: false,
            position: (714, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (770, 5),
             },
             Raw {
              content: "sessionVariables",
              position: (770, 17),
             },
            ],
           },
           BinaryOperation {
            operator: Update,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (770, 36),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "envVars",
                 position: (770, 40),
                },
               ],
              },
              default: None,
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "NIX_PATH",
                   position: (770, 53),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (770, 64),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "nixPath",
                    position: (770, 68),
                   },
                  ],
                 },
                 default: None,
                },
               ),
              ],
              recursive: false,
              position: (770, 51),
             },
            ],
            position: (770, 48),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (772, 5),
             },
             Raw {
              content: "extraInit",
              position: (772, 17),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "if [ -e \"$HOME/.nix-defexpr/channels\" ]; then\n  export NIX_PATH=\"$HOME/.nix-defexpr/channels",
              position: (774, 1),
             },
             Raw {
              content: "$",
              position: (775, 55),
             },
             Raw {
              content: "{NIX_PATH:+:$NIX_PATH}\"\nfi\n",
              position: (775, 58),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "nix",
              position: (779, 5),
             },
             Raw {
              content: "nrBuildUsers",
              position: (779, 9),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkDefault",
             position: (779, 24),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "max",
               position: (779, 35),
              },
              arguments: [
               Int {
                value: 32,
                position: (779, 39),
               },
               IfThenElse {
                predicate: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (779, 46),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "settings",
                      position: (779, 50),
                     },
                     Raw {
                      content: "max-jobs",
                      position: (779, 59),
                     },
                    ],
                   },
                   default: None,
                  },
                  String {
                   parts: [
                    Raw {
                     content: "auto",
                     position: (779, 72),
                    },
                   ],
                  },
                 ],
                 position: (779, 68),
                },
                then: Int {
                 value: 0,
                 position: (779, 83),
                },
                else_: PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (779, 90),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "settings",
                    position: (779, 94),
                   },
                   Raw {
                    content: "max-jobs",
                    position: (779, 103),
                   },
                  ],
                 },
                 default: None,
                },
                position: (779, 43),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (781, 5),
             },
             Raw {
              content: "users",
              position: (781, 11),
             },
            ],
           },
           Variable {
            identifier: "nixbldUsers",
            position: (781, 19),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "services",
              position: (783, 5),
             },
             Raw {
              content: "xserver",
              position: (783, 14),
             },
             Raw {
              content: "displayManager",
              position: (783, 22),
             },
             Raw {
              content: "hiddenUsers",
              position: (783, 37),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "attrNames",
             position: (783, 51),
            },
            arguments: [
             Variable {
              identifier: "nixbldUsers",
              position: (783, 61),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "system",
              position: (785, 5),
             },
             Raw {
              content: "activationScripts",
              position: (785, 12),
             },
             Raw {
              content: "nix",
              position: (785, 30),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "stringAfter",
             position: (785, 36),
            },
            arguments: [
             List {
              elements: [
               String {
                parts: [
                 Raw {
                  content: "etc",
                  position: (785, 51),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "users",
                  position: (785, 57),
                 },
                ],
               },
              ],
              position: (785, 48),
             },
             String {
              parts: [
               Raw {
                content: "install -m 0755 -d /nix/var/nix/{gcroots,profiles}/per-user\n\n# Subscribe the root user to the NixOS channel by default.\nif [ ! -e \"/root/.nix-channels\" ]; then\n    echo \"",
                position: (787, 1),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (791, 21),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "system",
                    position: (791, 28),
                   },
                   Raw {
                    content: "defaultChannel",
                    position: (791, 35),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: " nixos\" > \"/root/.nix-channels\"\nfi\n",
                position: (791, 50),
               },
              ],
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "nix",
              position: (796, 5),
             },
             Raw {
              content: "settings",
              position: (796, 9),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkMerge",
             position: (796, 20),
            },
            arguments: [
             List {
              elements: [
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "trusted-public-keys",
                     position: (798, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=",
                       position: (798, 34),
                      },
                     ],
                    },
                   ],
                   position: (798, 31),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "substituters",
                     position: (799, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkAfter",
                    position: (799, 24),
                   },
                   arguments: [
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "https://cache.nixos.org/",
                         position: (799, 35),
                        },
                       ],
                      },
                     ],
                     position: (799, 32),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "system-features",
                     position: (801, 9),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (801, 27),
                   },
                   arguments: [
                    BinaryOperation {
                     operator: Concatenation,
                     operands: [
                      List {
                       elements: [
                        String {
                         parts: [
                          Raw {
                           content: "nixos-test",
                           position: (802, 14),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "benchmark",
                           position: (802, 27),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "big-parallel",
                           position: (802, 39),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "kvm",
                           position: (802, 54),
                          },
                         ],
                        },
                       ],
                       position: (802, 11),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "optionals",
                        position: (803, 11),
                       },
                       arguments: [
                        HasProperty {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (803, 22),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "hostPlatform",
                             position: (803, 27),
                            },
                           ],
                          },
                          default: None,
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "gcc",
                            position: (803, 42),
                           },
                           Raw {
                            content: "arch",
                            position: (803, 46),
                           },
                          ],
                         },
                         position: (803, 40),
                        },
                        BinaryOperation {
                         operator: Concatenation,
                         operands: [
                          List {
                           elements: [
                            String {
                             parts: [
                              Raw {
                               content: "gccarch-",
                               position: (805, 16),
                              },
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (805, 26),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "hostPlatform",
                                   position: (805, 31),
                                  },
                                  Raw {
                                   content: "gcc",
                                   position: (805, 44),
                                  },
                                  Raw {
                                   content: "arch",
                                   position: (805, 48),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                             ],
                            },
                           ],
                           position: (805, 13),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "map",
                            position: (806, 13),
                           },
                           arguments: [
                            Function {
                             argument: Some(
                              "x",
                             ),
                             arguments: FunctionArguments {
                              arguments: [],
                              ellipsis: false,
                             },
                             definition: String {
                              parts: [
                               Raw {
                                content: "gccarch-",
                                position: (806, 22),
                               },
                               Expression {
                                expression: Variable {
                                 identifier: "x",
                                 position: (806, 32),
                                },
                               },
                              ],
                             },
                             position: (806, 18),
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "systems",
                              position: (806, 37),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "architectures",
                                position: (806, 45),
                               },
                               Raw {
                                content: "inferiors",
                                position: (806, 59),
                               },
                               Expression {
                                expression: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (806, 71),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "hostPlatform",
                                    position: (806, 76),
                                   },
                                   Raw {
                                    content: "gcc",
                                    position: (806, 89),
                                   },
                                   Raw {
                                    content: "arch",
                                    position: (806, 93),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         ],
                         position: (805, 57),
                        },
                       ],
                      },
                     ],
                     position: (802, 61),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (797, 7),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkIf",
                 position: (811, 8),
                },
                arguments: [
                 UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (811, 15),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "distributedBuilds",
                      position: (811, 19),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (811, 14),
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "builders",
                       position: (811, 40),
                      },
                     ],
                    },
                    Variable {
                     identifier: "null",
                     position: (811, 51),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (811, 38),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkIf",
                 position: (813, 8),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "isNixAtLeast",
                   position: (813, 14),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "2.3pre",
                      position: (813, 28),
                     },
                    ],
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "sandbox-fallback",
                       position: (813, 39),
                      },
                     ],
                    },
                    Variable {
                     identifier: "false",
                     position: (813, 58),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (813, 37),
                 },
                ],
               },
              ],
              position: (796, 28),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (656, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (113, 1),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}