---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "utils",
    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: "ids",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "ids",
         position: (6, 16),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "users",
         position: (7, 16),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isPasswdCompatible",
        position: (9, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "str",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: UnaryOperation {
       operator: Not,
       operand: BinaryOperation {
        operator: LogicalOr,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "hasInfix",
           position: (9, 31),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: ":",
              position: (9, 41),
             },
            ],
           },
           Variable {
            identifier: "str",
            position: (9, 44),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "hasInfix",
           position: (9, 51),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "\n",
              position: (9, 61),
             },
            ],
           },
           Variable {
            identifier: "str",
            position: (9, 65),
           },
          ],
         },
        ],
        position: (9, 48),
       },
       position: (9, 29),
      },
      position: (9, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "passwdEntry",
        position: (10, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "type",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: Update,
       operands: [
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (10, 23),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "types",
             position: (10, 27),
            },
            Raw {
             content: "addCheck",
             position: (10, 33),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Variable {
           identifier: "type",
           position: (10, 42),
          },
          Variable {
           identifier: "isPasswdCompatible",
           position: (10, 47),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "name",
              position: (11, 5),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "passwdEntry ",
              position: (11, 13),
             },
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (11, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "name",
                  position: (11, 32),
                 },
                ],
               },
               default: None,
              },
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "description",
              position: (12, 5),
             },
            ],
           },
           String {
            parts: [
             Expression {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (12, 22),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (12, 27),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: ", not containing newlines or colons",
              position: (12, 39),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (10, 69),
        },
       ],
       position: (10, 66),
      },
      position: (10, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "allowsLogin",
        position: (16, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "hash",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: EqualTo,
         operands: [
          Variable {
           identifier: "hash",
           position: (17, 5),
          },
          String {
           parts: [],
          },
         ],
         position: (17, 10),
        },
        UnaryOperation {
         operator: Not,
         operand: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (18, 10),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "elem",
              position: (18, 14),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "hash",
            position: (18, 19),
           },
           List {
            elements: [
             Variable {
              identifier: "null",
              position: (19, 9),
             },
             String {
              parts: [
               Raw {
                content: "!",
                position: (20, 10),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "!!",
                position: (21, 10),
               },
              ],
             },
             String {
              parts: [
               Raw {
                content: "*",
                position: (22, 10),
               },
              ],
             },
            ],
            position: (19, 7),
           },
          ],
         },
         position: (18, 8),
        },
       ],
       position: (18, 5),
      },
      position: (16, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "passwordDescription",
        position: (25, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "The options <option>hashedPassword</option>,\n<option>password</option> and <option>passwordFile</option>\ncontrols what password is set for the user.\n<option>hashedPassword</option> overrides both\n<option>password</option> and <option>passwordFile</option>.\n<option>password</option> overrides <option>passwordFile</option>.\nIf none of these three options are set, no password is assigned to\nthe user, and the user will not be able to do password logins.\nIf the option <option>users.mutableUsers</option> is true, the\npassword defined in one of the three options will only be set when\nthe user is created for the first time. After that, you are free to\nchange the password with the ordinary user management commands. If\n<option>users.mutableUsers</option> is false, you cannot change\nuser passwords, they will always be set according to the password\noptions.\n",
        position: (26, 1),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "hashedPasswordDescription",
        position: (43, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "To generate a hashed password run <literal>mkpasswd -m sha-512</literal>.\n\nIf set to an empty string (<literal>\"\"</literal>), this user will\nbe able to log in without being asked for a password (but not via remote\nservices such as SSH, or indirectly via <command>su</command> or\n<command>sudo</command>). This should only be used for e.g. bootable\nlive systems. Note: this is different from setting an empty password,\nwhich ca be achieved using <option>users.users.&lt;name?&gt;.password</option>.\n\nIf set to <literal>null</literal> (default) this user will not\nbe able to log in using a password (i.e. via <command>login</command>\ncommand).\n",
        position: (44, 1),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "userOpts",
        position: (58, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "config",
         default: None,
        },
        FunctionArgument {
         identifier: "name",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (60, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (62, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (62, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (63, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (63, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (63, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (63, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (64, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Assert {
                   expression: BinaryOperation {
                    operator: LogicalOr,
                    operands: [
                     BinaryOperation {
                      operator: LessThan,
                      operands: [
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "builtins",
                          position: (64, 28),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "stringLength",
                            position: (64, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Variable {
                          identifier: "x",
                          position: (64, 50),
                         },
                        ],
                       },
                       Int {
                        value: 32,
                        position: (64, 54),
                       },
                      ],
                      position: (64, 52),
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "abort",
                       position: (64, 60),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "Username '",
                          position: (64, 67),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "x",
                           position: (64, 79),
                          },
                         },
                         Raw {
                          content: "' is longer than 31 characters which is not allowed!",
                          position: (64, 81),
                         },
                        ],
                       },
                      ],
                     },
                    ],
                    position: (64, 57),
                   },
                   target: Variable {
                    identifier: "x",
                    position: (64, 137),
                   },
                   position: (64, 20),
                  },
                  position: (64, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (65, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The name of the user account. If undefined, the name of the\nattribute set will be used.\n",
                    position: (66, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (62, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "description",
               position: (71, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (71, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (72, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (72, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (72, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (72, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (73, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (74, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Alice Q. User",
                    position: (74, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (75, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "A short description of the user account, typically the\nuser's full name.  This is actually the “GECOS” or “comment”\nfield in <filename>/etc/passwd</filename>.\n",
                    position: (76, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (71, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "uid",
               position: (82, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (82, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (83, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (83, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (83, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "int",
                     position: (83, 35),
                    },
                   ],
                  },
                  position: (83, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (84, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (84, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (85, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The account UID. If the UID is null, a free UID is picked on\nactivation.\n",
                    position: (86, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (82, 22),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isSystemUser",
               position: (91, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (91, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (92, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (92, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (92, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (93, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (93, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (94, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Indicates if the user is a system user or not. This option\nonly has an effect if <option>uid</option> is\n<option>null</option>, in which case it determines whether\nthe user's UID is allocated in the range for system users\n(below 500) or in the range for normal users (starting at\n1000).\nExactly one of <literal>isNormalUser</literal> and\n<literal>isSystemUser</literal> must be true.\n",
                    position: (95, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (91, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isNormalUser",
               position: (106, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (106, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (107, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (107, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (107, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (108, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (108, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (109, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Indicates whether this is an account for a “real” user. This\nautomatically sets <option>group</option> to\n<literal>users</literal>, <option>createHome</option> to\n<literal>true</literal>, <option>home</option> to\n<filename>/home/<replaceable>username</replaceable></filename>,\n<option>useDefaultShell</option> to <literal>true</literal>,\nand <option>isSystemUser</option> to\n<literal>false</literal>.\nExactly one of <literal>isNormalUser</literal> and\n<literal>isSystemUser</literal> must be true.\n",
                    position: (110, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (106, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (123, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (123, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (124, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (124, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (124, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "apply",
                    position: (125, 9),
                   },
                  ],
                 },
                 Function {
                  argument: Some(
                   "x",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: Assert {
                   expression: BinaryOperation {
                    operator: LogicalOr,
                    operands: [
                     BinaryOperation {
                      operator: LessThan,
                      operands: [
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "builtins",
                          position: (125, 28),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "stringLength",
                            position: (125, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Variable {
                          identifier: "x",
                          position: (125, 50),
                         },
                        ],
                       },
                       Int {
                        value: 32,
                        position: (125, 54),
                       },
                      ],
                      position: (125, 52),
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "abort",
                       position: (125, 60),
                      },
                      arguments: [
                       String {
                        parts: [
                         Raw {
                          content: "Group name '",
                          position: (125, 67),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "x",
                           position: (125, 81),
                          },
                         },
                         Raw {
                          content: "' is longer than 31 characters which is not allowed!",
                          position: (125, 83),
                         },
                        ],
                       },
                      ],
                     },
                    ],
                    position: (125, 57),
                   },
                   target: Variable {
                    identifier: "x",
                    position: (125, 139),
                   },
                   position: (125, 20),
                  },
                  position: (125, 17),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (126, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (127, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The user's primary group.",
                    position: (127, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (123, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraGroups",
               position: (130, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (130, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (131, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (131, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (131, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (131, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (131, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (132, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (132, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (133, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The user's auxiliary groups.",
                    position: (133, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (130, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "home",
               position: (136, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (136, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (137, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (137, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (137, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (137, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (138, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/var/empty",
                    position: (138, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (139, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The user's home directory.",
                    position: (139, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (136, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cryptHomeLuks",
               position: (142, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (142, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (143, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (143, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (143, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (143, 35),
                    },
                   ],
                  },
                  position: (143, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (144, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (144, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (145, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to encrypted luks device that contains\nthe user's home directory.\n",
                    position: (146, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (142, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "pamMount",
               position: (151, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (151, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (152, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (152, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "attrsOf",
                    position: (152, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (152, 36),
                    },
                   ],
                  },
                  position: (152, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (153, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (153, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (154, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Attributes for user's entry in\n<filename>pam_mount.conf.xml</filename>.\nUseful attributes might include <code>path</code>,\n<code>options</code>, <code>fstype</code>, and <code>server</code>.\nSee <link\nxlink:href=\"http://pam-mount.sourceforge.net/pam_mount.conf.5.html\" />\nfor more information.\n",
                    position: (155, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (151, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shell",
               position: (165, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (165, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (166, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (166, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (166, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (166, 30),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "either",
                        position: (166, 36),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (166, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "shellPackage",
                         position: (166, 49),
                        },
                       ],
                      },
                      default: None,
                     },
                     FunctionApplication {
                      function: Variable {
                       identifier: "passwdEntry",
                       position: (166, 63),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (166, 75),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "path",
                           position: (166, 81),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (167, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (167, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "shadow",
                     position: (167, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (168, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (168, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.shadow",
                      position: (168, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (169, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (169, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.bashInteractive",
                      position: (169, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (170, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The path to the user's shell. Can use shell derivations,\nlike <literal>pkgs.bashInteractive</literal>. Don’t\nforget to enable your shell in\n<literal>programs</literal> if necessary,\nlike <code>programs.zsh.enable = true;</code>.\n",
                    position: (171, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (165, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "subUidRanges",
               position: (179, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (179, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (180, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (180, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (180, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (180, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "subordinateUidRange",
                       position: (180, 46),
                      },
                     ],
                    },
                   ],
                  },
                  position: (180, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (181, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (181, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (182, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "startUid",
                         position: (183, 13),
                        },
                       ],
                      },
                      Int {
                       value: 1000,
                       position: (183, 24),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "count",
                         position: (183, 30),
                        },
                       ],
                      },
                      Int {
                       value: 1,
                       position: (183, 38),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (183, 11),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "startUid",
                         position: (184, 13),
                        },
                       ],
                      },
                      Int {
                       value: 100001,
                       position: (184, 24),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "count",
                         position: (184, 32),
                        },
                       ],
                      },
                      Int {
                       value: 65534,
                       position: (184, 40),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (184, 11),
                   },
                  ],
                  position: (182, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (186, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Subordinate user ids that user is allowed to use.\nThey are set into <filename>/etc/subuid</filename> and are used\nby <literal>newuidmap</literal> for user namespaces.\n",
                    position: (187, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (179, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "subGidRanges",
               position: (193, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (193, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (194, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (194, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (194, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "submodule",
                      position: (194, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "subordinateGidRange",
                       position: (194, 46),
                      },
                     ],
                    },
                   ],
                  },
                  position: (194, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (195, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (195, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (196, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "startGid",
                         position: (197, 13),
                        },
                       ],
                      },
                      Int {
                       value: 100,
                       position: (197, 24),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "count",
                         position: (197, 29),
                        },
                       ],
                      },
                      Int {
                       value: 1,
                       position: (197, 37),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (197, 11),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "startGid",
                         position: (198, 13),
                        },
                       ],
                      },
                      Int {
                       value: 1001,
                       position: (198, 24),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "count",
                         position: (198, 30),
                        },
                       ],
                      },
                      Int {
                       value: 999,
                       position: (198, 38),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (198, 11),
                   },
                  ],
                  position: (196, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (200, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Subordinate group ids that user is allowed to use.\nThey are set into <filename>/etc/subgid</filename> and are used\nby <literal>newgidmap</literal> for user namespaces.\n",
                    position: (201, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (193, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "autoSubUidGidRange",
               position: (207, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (207, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (208, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (208, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (208, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (209, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (209, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (210, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "true",
                  position: (210, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (211, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Automatically allocate subordinate user and group ids for this user.\nAllocated range is currently always of size 65536.\n",
                    position: (212, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (207, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "createHome",
               position: (217, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (217, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (218, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (218, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (218, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (219, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (219, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (220, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to create the home directory and ensure ownership as well as\npermissions to match the user.\n",
                    position: (221, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (217, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "useDefaultShell",
               position: (226, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (226, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (227, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (227, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (227, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (228, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (228, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (229, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If true, the user's shell will be set to\n<option>users.defaultUserShell</option>.\n",
                    position: (230, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (226, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "hashedPassword",
               position: (235, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (235, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (236, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (236, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (236, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "passwdEntry",
                      position: (236, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (236, 48),
                      },
                     ],
                    },
                   ],
                  },
                  position: (236, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (237, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (237, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (238, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the hashed password for the user.\n",
                    position: (239, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "passwordDescription",
                     position: (240, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (240, 33),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "hashedPasswordDescription",
                     position: (241, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (241, 39),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (235, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "password",
               position: (245, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (245, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (246, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (246, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (246, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (246, 35),
                    },
                   ],
                  },
                  position: (246, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (247, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (247, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (248, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the (clear text) password for the user.\nWarning: do not set confidential information here\nbecause it is world-readable in the Nix store. This option\nshould only be used for public accounts.\n",
                    position: (249, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "passwordDescription",
                     position: (253, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (253, 33),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (245, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "passwordFile",
               position: (257, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (257, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (258, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (258, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (258, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (258, 35),
                    },
                   ],
                  },
                  position: (258, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (259, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (259, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (260, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The full path to a file that contains the user's password. The password\nfile is read on each system activation. The file should contain\nexactly one line, which should be the password in an encrypted form\nthat is suitable for the <literal>chpasswd -e</literal> command.\n",
                    position: (261, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "passwordDescription",
                     position: (265, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (265, 33),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (257, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "initialHashedPassword",
               position: (269, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (269, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (270, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (270, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (270, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "passwdEntry",
                      position: (270, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (270, 48),
                      },
                     ],
                    },
                   ],
                  },
                  position: (270, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (271, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (271, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (272, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the initial hashed password for the user, i.e. the\nhashed password assigned if the user does not already\nexist. If <option>users.mutableUsers</option> is true, the\npassword can be changed subsequently using the\n<command>passwd</command> command. Otherwise, it's\nequivalent to setting the <option>hashedPassword</option> option.\n\n",
                    position: (273, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "hashedPasswordDescription",
                     position: (280, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (280, 39),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (269, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "initialPassword",
               position: (284, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (284, 25),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (285, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (285, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (285, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (285, 35),
                    },
                   ],
                  },
                  position: (285, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (286, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (286, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (287, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Specifies the initial password for the user, i.e. the\npassword assigned if the user does not already exist. If\n<option>users.mutableUsers</option> is true, the password\ncan be changed subsequently using the\n<command>passwd</command> command. Otherwise, it's\nequivalent to setting the <option>password</option>\noption. The same caveat applies: the password specified here\nis world-readable in the Nix store, so it should only be\nused for guest accounts or passwords that will be changed\npromptly.\n",
                    position: (288, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (284, 34),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "packages",
               position: (301, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (301, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (302, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (302, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (302, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (302, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (302, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (303, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (303, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (304, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (304, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "[ pkgs.firefox pkgs.thunderbird ]",
                      position: (304, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (305, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The set of packages that should be made available to the user.\nThis is in contrast to <option>environment.systemPackages</option>,\nwhich adds packages to all users.\n",
                    position: (306, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (301, 27),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (60, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (314, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkMerge",
           position: (314, 14),
          },
          arguments: [
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "name",
                   position: (315, 11),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (315, 18),
                 },
                 arguments: [
                  Variable {
                   identifier: "name",
                   position: (315, 28),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "shell",
                   position: (316, 11),
                  },
                 ],
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (316, 19),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (316, 24),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "useDefaultShell",
                      position: (316, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (316, 48),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (316, 58),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "defaultUserShell",
                        position: (316, 62),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (315, 9),
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (318, 10),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (318, 15),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "isNormalUser",
                   position: (318, 22),
                  },
                 ],
                },
                default: None,
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (319, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (319, 19),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "users",
                       position: (319, 30),
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "createHome",
                     position: (320, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (320, 24),
                   },
                   arguments: [
                    Variable {
                     identifier: "true",
                     position: (320, 34),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "home",
                     position: (321, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (321, 18),
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "/home/",
                       position: (321, 29),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (321, 37),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "name",
                           position: (321, 44),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                     ],
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "useDefaultShell",
                     position: (322, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (322, 29),
                   },
                   arguments: [
                    Variable {
                     identifier: "true",
                     position: (322, 39),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "isSystemUser",
                     position: (323, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (323, 26),
                   },
                   arguments: [
                    Variable {
                     identifier: "false",
                     position: (323, 36),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (318, 35),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (327, 10),
              },
              arguments: [
               BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (327, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mutableUsers",
                      position: (327, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (327, 16),
                 },
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (327, 37),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "initialPassword",
                       position: (327, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "null",
                    position: (327, 63),
                   },
                  ],
                  position: (327, 60),
                 },
                ],
                position: (327, 34),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "password",
                     position: (328, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (328, 22),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (328, 32),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "initialPassword",
                        position: (328, 39),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (327, 69),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (330, 10),
              },
              arguments: [
               BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 UnaryOperation {
                  operator: Not,
                  operand: PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (330, 17),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "mutableUsers",
                      position: (330, 21),
                     },
                    ],
                   },
                   default: None,
                  },
                  position: (330, 16),
                 },
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (330, 37),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "initialHashedPassword",
                       position: (330, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                   Variable {
                    identifier: "null",
                    position: (330, 69),
                   },
                  ],
                  position: (330, 66),
                 },
                ],
                position: (330, 34),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "hashedPassword",
                     position: (331, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (331, 28),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (331, 38),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "initialHashedPassword",
                        position: (331, 45),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (330, 75),
               },
              ],
             },
             FunctionApplication {
              function: Variable {
               identifier: "mkIf",
               position: (333, 10),
              },
              arguments: [
               BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (333, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "isNormalUser",
                       position: (333, 23),
                      },
                     ],
                    },
                    default: None,
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (333, 39),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "subUidRanges",
                         position: (333, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                     List {
                      elements: [],
                      position: (333, 62),
                     },
                    ],
                    position: (333, 59),
                   },
                  ],
                  position: (333, 36),
                 },
                 BinaryOperation {
                  operator: EqualTo,
                  operands: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (333, 68),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "subGidRanges",
                       position: (333, 75),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [],
                    position: (333, 91),
                   },
                  ],
                  position: (333, 88),
                 },
                ],
                position: (333, 65),
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "autoSubUidGidRange",
                     position: (334, 11),
                    },
                   ],
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "mkDefault",
                    position: (334, 32),
                   },
                   arguments: [
                    Variable {
                     identifier: "true",
                     position: (334, 42),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (333, 95),
               },
              ],
             },
            ],
            position: (315, 7),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (58, 37),
      },
      position: (58, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "groupOpts",
        position: (340, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "config",
         default: None,
        },
        FunctionArgument {
         identifier: "name",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "options",
            position: (342, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (344, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (344, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (345, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (345, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (345, 28),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (345, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (346, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The name of the group. If undefined, the name of the attribute set\nwill be used.\n",
                    position: (347, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (344, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "gid",
               position: (352, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (352, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (353, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (353, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (353, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "int",
                     position: (353, 35),
                    },
                   ],
                  },
                  position: (353, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (354, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (354, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (355, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The group GID. If the GID is null, a free GID is picked on\nactivation.\n",
                    position: (356, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (352, 22),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "members",
               position: (361, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (361, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (362, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (362, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (362, 28),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "passwdEntry",
                      position: (362, 36),
                     },
                     arguments: [
                      Variable {
                       identifier: "str",
                       position: (362, 48),
                      },
                     ],
                    },
                   ],
                  },
                  position: (362, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (363, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (363, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (364, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "The user names of the group members, added to the\n<literal>/etc/group</literal> file.\n",
                    position: (365, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (361, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (342, 15),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "config",
            position: (372, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "name",
               position: (373, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkDefault",
              position: (373, 14),
             },
             arguments: [
              Variable {
               identifier: "name",
               position: (373, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "members",
               position: (375, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (375, 17),
             },
             arguments: [
              Function {
               argument: Some(
                "n",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "u",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: PropertyAccess {
                 expression: Variable {
                  identifier: "u",
                  position: (375, 39),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "name",
                    position: (375, 41),
                   },
                  ],
                 },
                 default: None,
                },
                position: (375, 36),
               },
               position: (375, 33),
              },
              FunctionApplication {
               function: Variable {
                identifier: "filterAttrs",
                position: (376, 9),
               },
               arguments: [
                Function {
                 argument: Some(
                  "n",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: Function {
                  argument: Some(
                   "u",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: FunctionApplication {
                   function: Variable {
                    identifier: "elem",
                    position: (376, 28),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (376, 33),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (376, 40),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "u",
                      position: (376, 45),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "extraGroups",
                        position: (376, 47),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                  },
                  position: (376, 25),
                 },
                 position: (376, 22),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (376, 60),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "users",
                    position: (376, 64),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (372, 14),
         },
        ),
       ],
       recursive: false,
       position: (340, 38),
      },
      position: (340, 15),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "subordinateUidRange",
        position: (382, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "options",
           position: (383, 5),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "startUid",
              position: (384, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (384, 18),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (385, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (385, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "int",
                    position: (385, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (386, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Start of the range of subordinate user ids that user is\nallowed to use.\n",
                   position: (387, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (384, 27),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "count",
              position: (391, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (391, 15),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (392, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (392, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "int",
                    position: (392, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (393, 9),
                  },
                 ],
                },
                Int {
                 value: 1,
                 position: (393, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (394, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Count of subordinate user ids",
                   position: (394, 24),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (391, 24),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (383, 15),
        },
       ),
      ],
      recursive: false,
      position: (382, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "subordinateGidRange",
        position: (399, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "options",
           position: (400, 5),
          },
         ],
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "startGid",
              position: (401, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (401, 18),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (402, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (402, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "int",
                    position: (402, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (403, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Start of the range of subordinate group ids that user is\nallowed to use.\n",
                   position: (404, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (401, 27),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "count",
              position: (408, 7),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (408, 15),
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "type",
                   position: (409, 9),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (409, 16),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "int",
                    position: (409, 22),
                   },
                  ],
                 },
                 default: None,
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "default",
                   position: (410, 9),
                  },
                 ],
                },
                Int {
                 value: 1,
                 position: (410, 19),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "description",
                   position: (411, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Count of subordinate group ids",
                   position: (411, 24),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (408, 24),
             },
            ],
           },
          ),
         ],
         recursive: false,
         position: (400, 15),
        },
       ),
      ],
      recursive: false,
      position: (399, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "idsAreUnique",
        position: (416, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "set",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "idAttr",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: UnaryOperation {
        operator: Not,
        operand: PropertyAccess {
         expression: FunctionApplication {
          function: Variable {
           identifier: "foldr",
           position: (416, 33),
          },
          arguments: [
           Function {
            argument: Some(
             "name",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "args",
             ),
             arguments: FunctionArguments {
              arguments: [
               FunctionArgument {
                identifier: "acc",
                default: None,
               },
               FunctionArgument {
                identifier: "dup",
                default: None,
               },
              ],
              ellipsis: false,
             },
             definition: LetIn {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "id",
                   position: (418, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (418, 12),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "toString",
                     position: (418, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (418, 31),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "getAttr",
                       position: (418, 40),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "idAttr",
                     position: (418, 48),
                    },
                    FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "builtins",
                       position: (418, 56),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "getAttr",
                         position: (418, 65),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      Variable {
                       identifier: "name",
                       position: (418, 73),
                      },
                      Variable {
                       identifier: "set",
                       position: (418, 78),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "exists",
                   position: (419, 7),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (419, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "hasAttr",
                     position: (419, 25),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Variable {
                   identifier: "id",
                   position: (419, 33),
                  },
                  Variable {
                   identifier: "acc",
                   position: (419, 36),
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "newAcc",
                   position: (420, 7),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Update,
                 operands: [
                  Variable {
                   identifier: "acc",
                   position: (420, 16),
                  },
                  FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (420, 24),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "listToAttrs",
                       position: (420, 33),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    List {
                     elements: [
                      Map {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "name",
                            position: (420, 49),
                           },
                          ],
                         },
                         Variable {
                          identifier: "id",
                          position: (420, 56),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "value",
                            position: (420, 60),
                           },
                          ],
                         },
                         Variable {
                          identifier: "true",
                          position: (420, 68),
                         },
                        ),
                       ],
                       recursive: false,
                       position: (420, 47),
                      },
                     ],
                     position: (420, 45),
                    },
                   ],
                  },
                 ],
                 position: (420, 20),
                },
               ),
              ],
              target: IfThenElse {
               predicate: Variable {
                identifier: "dup",
                position: (421, 11),
               },
               then: Variable {
                identifier: "args",
                position: (421, 20),
               },
               else_: IfThenElse {
                predicate: Variable {
                 identifier: "exists",
                 position: (421, 33),
                },
                then: FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "builtins",
                   position: (422, 12),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "trace",
                     position: (422, 21),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  String {
                   parts: [
                    Raw {
                     content: "Duplicate ",
                     position: (422, 28),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "idAttr",
                      position: (422, 40),
                     },
                    },
                    Raw {
                     content: " ",
                     position: (422, 47),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "id",
                      position: (422, 50),
                     },
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "dup",
                        position: (422, 57),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (422, 63),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "acc",
                        position: (422, 69),
                       },
                      ],
                     },
                     Variable {
                      identifier: "null",
                      position: (422, 75),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (422, 55),
                  },
                 ],
                },
                else_: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "dup",
                      position: (423, 14),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (423, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "acc",
                      position: (423, 27),
                     },
                    ],
                   },
                   Variable {
                    identifier: "newAcc",
                    position: (423, 33),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (423, 12),
                },
                position: (421, 30),
               },
               position: (421, 8),
              },
              position: (417, 5),
             },
             position: (416, 46),
            },
            position: (416, 40),
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "dup",
                 position: (424, 9),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (424, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "acc",
                 position: (424, 22),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (424, 28),
              },
             ),
            ],
            recursive: false,
            position: (424, 7),
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (424, 35),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "attrNames",
                position: (424, 44),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "set",
              position: (424, 54),
             },
            ],
           },
          ],
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "dup",
            position: (424, 60),
           },
          ],
         },
         default: None,
        },
        position: (416, 31),
       },
       position: (416, 23),
      },
      position: (416, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "uidsAreUnique",
        position: (426, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "idsAreUnique",
       position: (426, 19),
      },
      arguments: [
       FunctionApplication {
        function: Variable {
         identifier: "filterAttrs",
         position: (426, 33),
        },
        arguments: [
         Function {
          argument: Some(
           "n",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "u",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: BinaryOperation {
            operator: NotEqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "u",
               position: (426, 52),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (426, 54),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "null",
              position: (426, 61),
             },
            ],
            position: (426, 58),
           },
           position: (426, 49),
          },
          position: (426, 46),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (426, 67),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "users",
             position: (426, 71),
            },
           ],
          },
          default: None,
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "uid",
          position: (426, 79),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gidsAreUnique",
        position: (427, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "idsAreUnique",
       position: (427, 19),
      },
      arguments: [
       FunctionApplication {
        function: Variable {
         identifier: "filterAttrs",
         position: (427, 33),
        },
        arguments: [
         Function {
          argument: Some(
           "n",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: Function {
           argument: Some(
            "g",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: BinaryOperation {
            operator: NotEqualTo,
            operands: [
             PropertyAccess {
              expression: Variable {
               identifier: "g",
               position: (427, 52),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "gid",
                 position: (427, 54),
                },
               ],
              },
              default: None,
             },
             Variable {
              identifier: "null",
              position: (427, 61),
             },
            ],
            position: (427, 58),
           },
           position: (427, 49),
          },
          position: (427, 46),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (427, 67),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "groups",
             position: (427, 71),
            },
           ],
          },
          default: None,
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "gid",
          position: (427, 80),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "spec",
        position: (429, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (429, 10),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (429, 15),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "users-groups.json",
          position: (429, 26),
         },
        ],
       },
       FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "builtins",
          position: (429, 46),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "toJSON",
            position: (429, 55),
           },
          ],
         },
         default: None,
        },
        arguments: [
         Map {
          bindings: [
           Inherit(
            Some(
             Variable {
              identifier: "cfg",
              position: (430, 14),
             },
            ),
            [
             Raw {
              content: "mutableUsers",
              position: (430, 19),
             },
            ],
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (431, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (431, 13),
             },
             arguments: [
              Function {
               argument: Some(
                "_",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: Function {
                argument: Some(
                 "u",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Map {
                 bindings: [
                  Inherit(
                   Some(
                    Variable {
                     identifier: "u",
                     position: (432, 18),
                    },
                   ),
                   [
                    Raw {
                     content: "name",
                     position: (433, 11),
                    },
                    Raw {
                     content: "uid",
                     position: (433, 16),
                    },
                    Raw {
                     content: "group",
                     position: (433, 20),
                    },
                    Raw {
                     content: "description",
                     position: (433, 26),
                    },
                    Raw {
                     content: "home",
                     position: (433, 38),
                    },
                    Raw {
                     content: "createHome",
                     position: (433, 43),
                    },
                    Raw {
                     content: "isSystemUser",
                     position: (433, 54),
                    },
                    Raw {
                     content: "password",
                     position: (434, 11),
                    },
                    Raw {
                     content: "passwordFile",
                     position: (434, 20),
                    },
                    Raw {
                     content: "hashedPassword",
                     position: (434, 33),
                    },
                    Raw {
                     content: "autoSubUidGidRange",
                     position: (435, 11),
                    },
                    Raw {
                     content: "subUidRanges",
                     position: (435, 30),
                    },
                    Raw {
                     content: "subGidRanges",
                     position: (435, 43),
                    },
                    Raw {
                     content: "initialPassword",
                     position: (436, 11),
                    },
                    Raw {
                     content: "initialHashedPassword",
                     position: (436, 27),
                    },
                   ],
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "shell",
                      position: (437, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "utils",
                      position: (437, 17),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "toShellPath",
                        position: (437, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "u",
                       position: (437, 35),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "shell",
                         position: (437, 37),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (432, 7),
                },
                position: (431, 32),
               },
               position: (431, 29),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (438, 10),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (438, 14),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "groups",
               position: (439, 5),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "attrValues",
              position: (439, 14),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (439, 25),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "groups",
                  position: (439, 29),
                 },
                ],
               },
               default: None,
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (429, 62),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "systemShells",
        position: (442, 3),
       },
      ],
     },
     LetIn {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "shells",
           position: (444, 7),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mapAttrsToList",
          position: (444, 16),
         },
         arguments: [
          Function {
           argument: Some(
            "_",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: Function {
            argument: Some(
             "u",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: PropertyAccess {
             expression: Variable {
              identifier: "u",
              position: (444, 38),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "shell",
                position: (444, 40),
               },
              ],
             },
             default: None,
            },
            position: (444, 35),
           },
           position: (444, 32),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (444, 47),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (444, 51),
             },
            ],
           },
           default: None,
          },
         ],
        },
       ),
      ],
      target: FunctionApplication {
       function: Variable {
        identifier: "filter",
        position: (446, 7),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "types",
          position: (446, 14),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "shellPackage",
            position: (446, 20),
           },
           Raw {
            content: "check",
            position: (446, 33),
           },
          ],
         },
         default: None,
        },
        Variable {
         identifier: "shells",
         position: (446, 39),
        },
       ],
      },
      position: (443, 5),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (449, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkAliasOptionModule",
          position: (450, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "users",
               position: (450, 29),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "extraUsers",
               position: (450, 37),
              },
             ],
            },
           ],
           position: (450, 26),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "users",
               position: (450, 54),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "users",
               position: (450, 62),
              },
             ],
            },
           ],
           position: (450, 51),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkAliasOptionModule",
          position: (451, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "users",
               position: (451, 29),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "extraGroups",
               position: (451, 37),
              },
             ],
            },
           ],
           position: (451, 26),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "users",
               position: (451, 55),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "groups",
               position: (451, 63),
              },
             ],
            },
           ],
           position: (451, 52),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (452, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "security",
               position: (452, 30),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "initialRootPassword",
               position: (452, 41),
              },
             ],
            },
           ],
           position: (452, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "users",
               position: (452, 65),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "users",
               position: (452, 73),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "root",
               position: (452, 81),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "initialHashedPassword",
               position: (452, 88),
              },
             ],
            },
           ],
           position: (452, 63),
          },
         ],
        },
       ],
       position: (449, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (456, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (458, 5),
           },
           Raw {
            content: "mutableUsers",
            position: (458, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (458, 26),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (459, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (459, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (459, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (460, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (460, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (461, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "If set to <literal>true</literal>, you are free to add new users and groups to the system\nwith the ordinary <literal>useradd</literal> and\n<literal>groupadd</literal> commands. On system activation, the\nexisting contents of the <literal>/etc/passwd</literal> and\n<literal>/etc/group</literal> files will be merged with the\ncontents generated from the <literal>users.users</literal> and\n<literal>users.groups</literal> options.\nThe initial password for a user will be set\naccording to <literal>users.users</literal>, but existing passwords\nwill not be changed.\n\n<warning><para>\nIf set to <literal>false</literal>, the contents of the user and\ngroup files will simply be replaced on system activation. This also\nholds for the user passwords; all changed\npasswords will be reset according to the\n<literal>users.users</literal> configuration on activation.\n</para></warning>\n",
                 position: (462, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (458, 35),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (483, 5),
           },
           Raw {
            content: "enforceIdUniqueness",
            position: (483, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (483, 33),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (484, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (484, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (484, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (485, 7),
                },
               ],
              },
              Variable {
               identifier: "true",
               position: (485, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (486, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Whether to require that no two users/groups share the same uid/gid.\n",
                 position: (487, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (483, 42),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (491, 5),
           },
           Raw {
            content: "users",
            position: (491, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (491, 19),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (492, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (492, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (493, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (493, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (493, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (493, 35),
                  },
                  arguments: [
                   Variable {
                    identifier: "userOpts",
                    position: (493, 45),
                   },
                  ],
                 },
                ],
               },
               position: (493, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (494, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "alice",
                    position: (495, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "uid",
                       position: (496, 11),
                      },
                     ],
                    },
                    Int {
                     value: 1234,
                     position: (496, 17),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (497, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Alice Q. User",
                       position: (497, 26),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "home",
                       position: (498, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/home/alice",
                       position: (498, 19),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "createHome",
                       position: (499, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (499, 24),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "group",
                       position: (500, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "users",
                       position: (500, 20),
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "extraGroups",
                       position: (501, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "wheel",
                         position: (501, 27),
                        },
                       ],
                      },
                     ],
                     position: (501, 25),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "shell",
                       position: (502, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "/bin/sh",
                       position: (502, 20),
                      },
                     ],
                    },
                   ),
                  ],
                  recursive: false,
                  position: (495, 17),
                 },
                ),
               ],
               recursive: false,
               position: (494, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (505, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Additional user accounts to be created automatically by the system.\nThis can also be used to set options for root.\n",
                 position: (506, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (491, 28),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (511, 5),
           },
           Raw {
            content: "groups",
            position: (511, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (511, 20),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (512, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (512, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (513, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "students",
                    position: (514, 11),
                   },
                   Raw {
                    content: "gid",
                    position: (514, 20),
                   },
                  ],
                 },
                 Int {
                  value: 1001,
                  position: (514, 26),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "hackers",
                    position: (515, 11),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (515, 21),
                 },
                ),
               ],
               recursive: false,
               position: (514, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (517, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (517, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (517, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (517, 35),
                  },
                  arguments: [
                   Variable {
                    identifier: "groupOpts",
                    position: (517, 45),
                   },
                  ],
                 },
                ],
               },
               position: (517, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (518, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Additional groups to be created automatically by the system.\n",
                 position: (519, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (511, 29),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (524, 5),
           },
           Raw {
            content: "allowNoPasswordLogin",
            position: (524, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (524, 34),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (525, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (525, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (525, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (526, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (526, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (527, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Disable checking that at least the <literal>root</literal> user or a user in the <literal>wheel</literal> group can log in using\na password or an SSH key.\n\nWARNING: enabling this can lock you out of your system. Enable this only if you know what are you doing.\n",
                 position: (528, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (524, 43),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (456, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (539, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (541, 5),
           },
           Raw {
            content: "users",
            position: (541, 11),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "root",
               position: (542, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "uid",
                  position: (543, 9),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "ids",
                 position: (543, 15),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "uids",
                   position: (543, 19),
                  },
                  Raw {
                   content: "root",
                   position: (543, 24),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (544, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "System administrator",
                  position: (544, 24),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "home",
                  position: (545, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "/root",
                  position: (545, 17),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "shell",
                  position: (546, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (546, 17),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (546, 27),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "defaultUserShell",
                     position: (546, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (547, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "root",
                  position: (547, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "initialHashedPassword",
                  position: (548, 9),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (548, 33),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "!",
                    position: (548, 44),
                   },
                  ],
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (542, 14),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nobody",
               position: (550, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "uid",
                  position: (551, 9),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "ids",
                 position: (551, 15),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "uids",
                   position: (551, 19),
                  },
                  Raw {
                   content: "nobody",
                   position: (551, 24),
                  },
                 ],
                },
                default: None,
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "isSystemUser",
                  position: (552, 9),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (552, 24),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "description",
                  position: (553, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "Unprivileged account (don't use!)",
                  position: (553, 24),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (554, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "nogroup",
                  position: (554, 18),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (550, 16),
            },
           ),
          ],
          recursive: false,
          position: (541, 19),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (558, 5),
           },
           Raw {
            content: "groups",
            position: (558, 11),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "root",
               position: (559, 7),
              },
              Raw {
               content: "gid",
               position: (559, 12),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (559, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (559, 22),
               },
               Raw {
                content: "root",
                position: (559, 27),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "wheel",
               position: (560, 7),
              },
              Raw {
               content: "gid",
               position: (560, 13),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (560, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (560, 23),
               },
               Raw {
                content: "wheel",
                position: (560, 28),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "disk",
               position: (561, 7),
              },
              Raw {
               content: "gid",
               position: (561, 12),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (561, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (561, 22),
               },
               Raw {
                content: "disk",
                position: (561, 27),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "kmem",
               position: (562, 7),
              },
              Raw {
               content: "gid",
               position: (562, 12),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (562, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (562, 22),
               },
               Raw {
                content: "kmem",
                position: (562, 27),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tty",
               position: (563, 7),
              },
              Raw {
               content: "gid",
               position: (563, 11),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (563, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (563, 21),
               },
               Raw {
                content: "tty",
                position: (563, 26),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "floppy",
               position: (564, 7),
              },
              Raw {
               content: "gid",
               position: (564, 14),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (564, 20),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (564, 24),
               },
               Raw {
                content: "floppy",
                position: (564, 29),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "uucp",
               position: (565, 7),
              },
              Raw {
               content: "gid",
               position: (565, 12),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (565, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (565, 22),
               },
               Raw {
                content: "uucp",
                position: (565, 27),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "lp",
               position: (566, 7),
              },
              Raw {
               content: "gid",
               position: (566, 10),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (566, 16),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (566, 20),
               },
               Raw {
                content: "lp",
                position: (566, 25),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cdrom",
               position: (567, 7),
              },
              Raw {
               content: "gid",
               position: (567, 13),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (567, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (567, 23),
               },
               Raw {
                content: "cdrom",
                position: (567, 28),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "tape",
               position: (568, 7),
              },
              Raw {
               content: "gid",
               position: (568, 12),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (568, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (568, 22),
               },
               Raw {
                content: "tape",
                position: (568, 27),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "audio",
               position: (569, 7),
              },
              Raw {
               content: "gid",
               position: (569, 13),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (569, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (569, 23),
               },
               Raw {
                content: "audio",
                position: (569, 28),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "video",
               position: (570, 7),
              },
              Raw {
               content: "gid",
               position: (570, 13),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (570, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (570, 23),
               },
               Raw {
                content: "video",
                position: (570, 28),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "dialout",
               position: (571, 7),
              },
              Raw {
               content: "gid",
               position: (571, 15),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (571, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (571, 25),
               },
               Raw {
                content: "dialout",
                position: (571, 30),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nogroup",
               position: (572, 7),
              },
              Raw {
               content: "gid",
               position: (572, 15),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (572, 21),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (572, 25),
               },
               Raw {
                content: "nogroup",
                position: (572, 30),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "users",
               position: (573, 7),
              },
              Raw {
               content: "gid",
               position: (573, 13),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (573, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (573, 23),
               },
               Raw {
                content: "users",
                position: (573, 28),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "nixbld",
               position: (574, 7),
              },
              Raw {
               content: "gid",
               position: (574, 14),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (574, 20),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (574, 24),
               },
               Raw {
                content: "nixbld",
                position: (574, 29),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "utmp",
               position: (575, 7),
              },
              Raw {
               content: "gid",
               position: (575, 12),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (575, 18),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (575, 22),
               },
               Raw {
                content: "utmp",
                position: (575, 27),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "adm",
               position: (576, 7),
              },
              Raw {
               content: "gid",
               position: (576, 11),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (576, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (576, 21),
               },
               Raw {
                content: "adm",
                position: (576, 26),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "input",
               position: (577, 7),
              },
              Raw {
               content: "gid",
               position: (577, 13),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (577, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (577, 23),
               },
               Raw {
                content: "input",
                position: (577, 28),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "kvm",
               position: (578, 7),
              },
              Raw {
               content: "gid",
               position: (578, 11),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (578, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (578, 21),
               },
               Raw {
                content: "kvm",
                position: (578, 26),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "render",
               position: (579, 7),
              },
              Raw {
               content: "gid",
               position: (579, 14),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (579, 20),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (579, 24),
               },
               Raw {
                content: "render",
                position: (579, 29),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "sgx",
               position: (580, 7),
              },
              Raw {
               content: "gid",
               position: (580, 11),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (580, 17),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (580, 21),
               },
               Raw {
                content: "sgx",
                position: (580, 26),
               },
              ],
             },
             default: None,
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "shadow",
               position: (581, 7),
              },
              Raw {
               content: "gid",
               position: (581, 14),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (581, 20),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "gids",
                position: (581, 24),
               },
               Raw {
                content: "shadow",
                position: (581, 29),
               },
              ],
             },
             default: None,
            },
           ),
          ],
          recursive: false,
          position: (558, 20),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (584, 5),
           },
           Raw {
            content: "activationScripts",
            position: (584, 12),
           },
           Raw {
            content: "users",
            position: (584, 30),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "supportsDryActivation",
               position: (585, 7),
              },
             ],
            },
            Variable {
             identifier: "true",
             position: (585, 31),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "text",
               position: (586, 7),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "install -m 0700 -d /root\ninstall -m 0755 -d /home\n\n",
               position: (587, 1),
              },
              Expression {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (590, 11),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "perl",
                    position: (590, 16),
                   },
                   Raw {
                    content: "withPackages",
                    position: (590, 21),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Function {
                  argument: Some(
                   "p",
                  ),
                  arguments: FunctionArguments {
                   arguments: [],
                   ellipsis: false,
                  },
                  definition: List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "p",
                      position: (590, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "FileSlurp",
                        position: (590, 42),
                       },
                      ],
                     },
                     default: None,
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "p",
                      position: (590, 52),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "JSON",
                        position: (590, 54),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (590, 38),
                  },
                  position: (590, 35),
                 },
                ],
               },
              },
              Raw {
               content: "/bin/perl \\\n-w ",
               position: (590, 62),
              },
              Expression {
               expression: Path {
                parts: [
                 Raw {
                  content: "./update-users-groups.pl",
                  position: (591, 14),
                 },
                ],
               },
              },
              Raw {
               content: " ",
               position: (591, 39),
              },
              Expression {
               expression: Variable {
                identifier: "spec",
                position: (591, 42),
               },
              },
              Raw {
               content: "\n",
               position: (591, 47),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (584, 38),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "system",
            position: (596, 5),
           },
           Raw {
            content: "activationScripts",
            position: (596, 12),
           },
           Raw {
            content: "groups",
            position: (596, 30),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "stringAfter",
           position: (596, 39),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (596, 54),
               },
              ],
             },
            ],
            position: (596, 51),
           },
           String {
            parts: [],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (599, 5),
           },
           Raw {
            content: "systemPackages",
            position: (599, 17),
           },
          ],
         },
         Variable {
          identifier: "systemShells",
          position: (599, 34),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (601, 5),
           },
           Raw {
            content: "etc",
            position: (601, 17),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mapAttrs'",
           position: (601, 24),
          },
          arguments: [
           Function {
            argument: Some(
             "_",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: None,
             arguments: FunctionArguments {
              arguments: [
               FunctionArgument {
                identifier: "name",
                default: None,
               },
               FunctionArgument {
                identifier: "packages",
                default: None,
               },
              ],
              ellipsis: true,
             },
             definition: Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "name",
                   position: (602, 7),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "profiles/per-user/",
                   position: (602, 15),
                  },
                  Expression {
                   expression: Variable {
                    identifier: "name",
                    position: (602, 35),
                   },
                  },
                 ],
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "value",
                   position: (603, 7),
                  },
                  Raw {
                   content: "source",
                   position: (603, 13),
                  },
                 ],
                },
                FunctionApplication {
                 function: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (603, 22),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "buildEnv",
                     position: (603, 27),
                    },
                   ],
                  },
                  default: None,
                 },
                 arguments: [
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (604, 9),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "user-environment",
                        position: (604, 17),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "paths",
                        position: (605, 9),
                       },
                      ],
                     },
                     Variable {
                      identifier: "packages",
                      position: (605, 17),
                     },
                    ),
                    Inherit(
                     Some(
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (606, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "environment",
                          position: (606, 25),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     [
                      Raw {
                       content: "pathsToLink",
                       position: (606, 38),
                      },
                      Raw {
                       content: "extraOutputsToInstall",
                       position: (606, 50),
                      },
                     ],
                    ),
                    Inherit(
                     Some(
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (607, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "system",
                          position: (607, 25),
                         },
                         Raw {
                          content: "path",
                          position: (607, 32),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     [
                      Raw {
                       content: "ignoreCollisions",
                       position: (607, 38),
                      },
                      Raw {
                       content: "postBuild",
                       position: (607, 55),
                      },
                     ],
                    ),
                   ],
                   recursive: false,
                   position: (603, 36),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (601, 63),
             },
             position: (601, 38),
            },
            position: (601, 35),
           },
           FunctionApplication {
            function: Variable {
             identifier: "filterAttrs",
             position: (609, 9),
            },
            arguments: [
             Function {
              argument: Some(
               "_",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "u",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: NotEqualTo,
                operands: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "u",
                   position: (609, 28),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "packages",
                     position: (609, 30),
                    },
                   ],
                  },
                  default: None,
                 },
                 List {
                  elements: [],
                  position: (609, 42),
                 },
                ],
                position: (609, 39),
               },
               position: (609, 25),
              },
              position: (609, 22),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (609, 46),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "users",
                 position: (609, 50),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (611, 5),
           },
           Raw {
            content: "profiles",
            position: (611, 17),
           },
          ],
         },
         List {
          elements: [
           String {
            parts: [
             Raw {
              content: "$HOME/.nix-profile",
              position: (612, 8),
             },
            ],
           },
           String {
            parts: [
             Raw {
              content: "/etc/profiles/per-user/$USER",
              position: (613, 8),
             },
            ],
           },
          ],
          position: (611, 28),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "assertions",
            position: (616, 5),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (617, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  UnaryOperation {
                   operator: Not,
                   operand: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (617, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enforceIdUniqueness",
                       position: (617, 26),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (617, 21),
                  },
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    Variable {
                     identifier: "uidsAreUnique",
                     position: (617, 50),
                    },
                    Variable {
                     identifier: "gidsAreUnique",
                     position: (617, 67),
                    },
                   ],
                   position: (617, 64),
                  },
                 ],
                 position: (617, 46),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (618, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "UIDs and GIDs must be unique!",
                   position: (618, 20),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (617, 7),
             },
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "assertion",
                   position: (627, 9),
                  },
                 ],
                },
                BinaryOperation {
                 operator: Implication,
                 operands: [
                  UnaryOperation {
                   operator: Not,
                   operand: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (627, 22),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "mutableUsers",
                       position: (627, 26),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (627, 21),
                  },
                  BinaryOperation {
                   operator: Implication,
                   operands: [
                    UnaryOperation {
                     operator: Not,
                     operand: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (627, 43),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "allowNoPasswordLogin",
                         position: (627, 47),
                        },
                       ],
                      },
                      default: None,
                     },
                     position: (627, 42),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "any",
                      position: (628, 11),
                     },
                     arguments: [
                      Variable {
                       identifier: "id",
                       position: (628, 15),
                      },
                      BinaryOperation {
                       operator: Concatenation,
                       operands: [
                        FunctionApplication {
                         function: Variable {
                          identifier: "mapAttrsToList",
                          position: (628, 19),
                         },
                         arguments: [
                          Function {
                           argument: Some(
                            "name",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: Function {
                            argument: Some(
                             "cfg",
                            ),
                            arguments: FunctionArguments {
                             arguments: [],
                             ellipsis: false,
                            },
                            definition: BinaryOperation {
                             operator: LogicalAnd,
                             operands: [
                              BinaryOperation {
                               operator: LogicalOr,
                               operands: [
                                BinaryOperation {
                                 operator: LogicalOr,
                                 operands: [
                                  BinaryOperation {
                                   operator: EqualTo,
                                   operands: [
                                    Variable {
                                     identifier: "name",
                                     position: (629, 14),
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "root",
                                       position: (629, 23),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (629, 19),
                                  },
                                  BinaryOperation {
                                   operator: EqualTo,
                                   operands: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (630, 17),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "group",
                                        position: (630, 21),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "wheel",
                                       position: (630, 31),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (630, 27),
                                  },
                                 ],
                                 position: (630, 14),
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "elem",
                                  position: (631, 17),
                                 },
                                 arguments: [
                                  String {
                                   parts: [
                                    Raw {
                                     content: "wheel",
                                     position: (631, 23),
                                    },
                                   ],
                                  },
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (631, 30),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "extraGroups",
                                      position: (631, 34),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                 ],
                                },
                               ],
                               position: (631, 14),
                              },
                              BinaryOperation {
                               operator: LogicalOr,
                               operands: [
                                BinaryOperation {
                                 operator: LogicalOr,
                                 operands: [
                                  BinaryOperation {
                                   operator: LogicalOr,
                                   operands: [
                                    BinaryOperation {
                                     operator: LogicalOr,
                                     operands: [
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "allowsLogin",
                                        position: (633, 14),
                                       },
                                       arguments: [
                                        PropertyAccess {
                                         expression: Variable {
                                          identifier: "cfg",
                                          position: (633, 26),
                                         },
                                         attribute_path: AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "hashedPassword",
                                            position: (633, 30),
                                           },
                                          ],
                                         },
                                         default: None,
                                        },
                                       ],
                                      },
                                      BinaryOperation {
                                       operator: NotEqualTo,
                                       operands: [
                                        PropertyAccess {
                                         expression: Variable {
                                          identifier: "cfg",
                                          position: (634, 17),
                                         },
                                         attribute_path: AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "password",
                                            position: (634, 21),
                                           },
                                          ],
                                         },
                                         default: None,
                                        },
                                        Variable {
                                         identifier: "null",
                                         position: (634, 33),
                                        },
                                       ],
                                       position: (634, 30),
                                      },
                                     ],
                                     position: (634, 14),
                                    },
                                    BinaryOperation {
                                     operator: NotEqualTo,
                                     operands: [
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (635, 17),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "passwordFile",
                                          position: (635, 21),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                      Variable {
                                       identifier: "null",
                                       position: (635, 37),
                                      },
                                     ],
                                     position: (635, 34),
                                    },
                                   ],
                                   position: (635, 14),
                                  },
                                  BinaryOperation {
                                   operator: NotEqualTo,
                                   operands: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (636, 17),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "openssh",
                                        position: (636, 21),
                                       },
                                       Raw {
                                        content: "authorizedKeys",
                                        position: (636, 29),
                                       },
                                       Raw {
                                        content: "keys",
                                        position: (636, 44),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    List {
                                     elements: [],
                                     position: (636, 52),
                                    },
                                   ],
                                   position: (636, 49),
                                  },
                                 ],
                                 position: (636, 14),
                                },
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (637, 17),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "openssh",
                                      position: (637, 21),
                                     },
                                     Raw {
                                      content: "authorizedKeys",
                                      position: (637, 29),
                                     },
                                     Raw {
                                      content: "keyFiles",
                                      position: (637, 44),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  List {
                                   elements: [],
                                   position: (637, 56),
                                  },
                                 ],
                                 position: (637, 53),
                                },
                               ],
                               position: (637, 14),
                              },
                             ],
                             position: (632, 13),
                            },
                            position: (628, 41),
                           },
                           position: (628, 35),
                          },
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (638, 13),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "users",
                              position: (638, 17),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        List {
                         elements: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "config",
                            position: (639, 13),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "security",
                              position: (639, 20),
                             },
                             Raw {
                              content: "googleOsLogin",
                              position: (639, 29),
                             },
                             Raw {
                              content: "enable",
                              position: (639, 43),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                         position: (638, 26),
                        },
                       ],
                       position: (638, 23),
                      },
                     ],
                    },
                   ],
                   position: (627, 68),
                  },
                 ],
                 position: (627, 39),
                },
               ),
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "message",
                   position: (641, 9),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "Neither the root account nor any wheel user has a password or SSH authorized key.\nYou must set one to prevent being locked out of your system.\nIf you really want to be locked out of your system, set users.allowNoPasswordLogin = true;\nHowever you are most probably better off by setting users.mutableUsers = true; and\nmanually running passwd root to set the root password.\n",
                   position: (642, 1),
                  },
                 ],
                },
               ),
              ],
              recursive: false,
              position: (620, 7),
             },
            ],
            position: (616, 18),
           },
           FunctionApplication {
            function: Variable {
             identifier: "flatten",
             position: (649, 10),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "flip",
               position: (649, 19),
              },
              arguments: [
               Variable {
                identifier: "mapAttrsToList",
                position: (649, 24),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (649, 39),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "users",
                   position: (649, 43),
                  },
                 ],
                },
                default: None,
               },
               Function {
                argument: Some(
                 "name",
                ),
                arguments: FunctionArguments {
                 arguments: [],
                 ellipsis: false,
                },
                definition: Function {
                 argument: Some(
                  "user",
                 ),
                 arguments: FunctionArguments {
                  arguments: [],
                  ellipsis: false,
                 },
                 definition: List {
                  elements: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "assertion",
                         position: (652, 9),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: Implication,
                       operands: [
                        BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "user",
                            position: (652, 22),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "hashedPassword",
                              position: (652, 27),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "null",
                           position: (652, 45),
                          },
                         ],
                         position: (652, 42),
                        },
                        BinaryOperation {
                         operator: EqualTo,
                         operands: [
                          FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (653, 13),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "match",
                               position: (653, 22),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            String {
                             parts: [
                              Raw {
                               content: ".*:.*",
                               position: (653, 29),
                              },
                             ],
                            },
                            PropertyAccess {
                             expression: Variable {
                              identifier: "user",
                              position: (653, 36),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "hashedPassword",
                                position: (653, 41),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                          Variable {
                           identifier: "null",
                           position: (653, 59),
                          },
                         ],
                         position: (653, 56),
                        },
                       ],
                       position: (653, 9),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "message",
                         position: (654, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "            The password hash of user \"",
                         position: (655, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (655, 42),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (655, 47),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "\" contains a \":\" character.\nThis is invalid and would break the login system because the fields\nof /etc/shadow (file where hashes are stored) are colon-separated.\nPlease check the value of option `users.users.\"",
                         position: (655, 52),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (658, 62),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (658, 67),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "\".hashedPassword`.",
                         position: (658, 72),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (651, 9),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "assertion",
                         position: (661, 13),
                        },
                       ],
                      },
                      LetIn {
                       bindings: [
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "xor",
                            position: (662, 15),
                           },
                          ],
                         },
                         Function {
                          argument: Some(
                           "a",
                          ),
                          arguments: FunctionArguments {
                           arguments: [],
                           ellipsis: false,
                          },
                          definition: Function {
                           argument: Some(
                            "b",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: BinaryOperation {
                            operator: LogicalOr,
                            operands: [
                             BinaryOperation {
                              operator: LogicalAnd,
                              operands: [
                               Variable {
                                identifier: "a",
                                position: (662, 27),
                               },
                               UnaryOperation {
                                operator: Not,
                                operand: Variable {
                                 identifier: "b",
                                 position: (662, 33),
                                },
                                position: (662, 32),
                               },
                              ],
                              position: (662, 29),
                             },
                             BinaryOperation {
                              operator: LogicalAnd,
                              operands: [
                               Variable {
                                identifier: "b",
                                position: (662, 38),
                               },
                               UnaryOperation {
                                operator: Not,
                                operand: Variable {
                                 identifier: "a",
                                 position: (662, 44),
                                },
                                position: (662, 43),
                               },
                              ],
                              position: (662, 40),
                             },
                            ],
                            position: (662, 35),
                           },
                           position: (662, 24),
                          },
                          position: (662, 21),
                         },
                        ),
                        KeyValue(
                         AttributePath {
                          attributes: [
                           Raw {
                            content: "isEffectivelySystemUser",
                            position: (663, 15),
                           },
                          ],
                         },
                         BinaryOperation {
                          operator: LogicalOr,
                          operands: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (663, 41),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "isSystemUser",
                               position: (663, 46),
                              },
                             ],
                            },
                            default: None,
                           },
                           BinaryOperation {
                            operator: LogicalAnd,
                            operands: [
                             BinaryOperation {
                              operator: NotEqualTo,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "user",
                                 position: (663, 63),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "uid",
                                   position: (663, 68),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               Variable {
                                identifier: "null",
                                position: (663, 75),
                               },
                              ],
                              position: (663, 72),
                             },
                             BinaryOperation {
                              operator: LessThan,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "user",
                                 position: (663, 83),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "uid",
                                   position: (663, 88),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               Int {
                                value: 500,
                                position: (663, 94),
                               },
                              ],
                              position: (663, 92),
                             },
                            ],
                            position: (663, 80),
                           },
                          ],
                          position: (663, 59),
                         },
                        ),
                       ],
                       target: FunctionApplication {
                        function: Variable {
                         identifier: "xor",
                         position: (664, 16),
                        },
                        arguments: [
                         Variable {
                          identifier: "isEffectivelySystemUser",
                          position: (664, 20),
                         },
                         PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (664, 44),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "isNormalUser",
                             position: (664, 49),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                       position: (661, 25),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "message",
                         position: (665, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Exactly one of users.users.",
                         position: (666, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (666, 44),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (666, 49),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: ".isSystemUser and users.users.",
                         position: (666, 54),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (666, 86),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (666, 91),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: ".isNormalUser must be set.\n",
                         position: (666, 96),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (660, 11),
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "assertion",
                         position: (670, 13),
                        },
                       ],
                      },
                      BinaryOperation {
                       operator: NotEqualTo,
                       operands: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "user",
                          position: (670, 25),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "group",
                            position: (670, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [],
                        },
                       ],
                       position: (670, 36),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "message",
                         position: (671, 13),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "users.users.",
                         position: (672, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (672, 29),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (672, 34),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: ".group is unset. This used to default to\nnogroup, but this is unsafe. For example you can create a group\nfor this user with:\nusers.users.",
                         position: (672, 39),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (675, 29),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (675, 34),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: ".group = \"",
                         position: (675, 39),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (675, 51),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (675, 56),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "\";\nusers.groups.",
                         position: (675, 61),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "user",
                           position: (676, 30),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "name",
                             position: (676, 35),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: " = {};\n",
                         position: (676, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (669, 11),
                   },
                  ],
                  position: (650, 7),
                 },
                 position: (649, 56),
                },
                position: (649, 50),
               },
              ],
             },
            ],
           },
          ],
          position: (649, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "warnings",
            position: (682, 5),
           },
          ],
         },
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (683, 7),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "filter",
              position: (683, 16),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Function {
            argument: Some(
             "x",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "x",
               position: (683, 27),
              },
              Variable {
               identifier: "null",
               position: (683, 32),
              },
             ],
             position: (683, 29),
            },
            position: (683, 24),
           },
           FunctionApplication {
            function: Variable {
             identifier: "flip",
             position: (684, 9),
            },
            arguments: [
             Variable {
              identifier: "mapAttrsToList",
              position: (684, 14),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (684, 29),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "users",
                 position: (684, 33),
                },
               ],
              },
              default: None,
             },
             Function {
              argument: Some(
               "_",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "user",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "sep",
                     position: (694, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "\\$",
                     position: (694, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "base64",
                     position: (695, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "[a-zA-Z0-9./]+",
                     position: (695, 21),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "id",
                     position: (696, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "[a-z0-9-]+",
                     position: (696, 17),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "value",
                     position: (697, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "[a-zA-Z0-9/+.-]+",
                     position: (697, 20),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "options",
                     position: (698, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "id",
                      position: (698, 24),
                     },
                    },
                    Raw {
                     content: "(=",
                     position: (698, 27),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "value",
                      position: (698, 31),
                     },
                    },
                    Raw {
                     content: ")?(,",
                     position: (698, 37),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "id",
                      position: (698, 43),
                     },
                    },
                    Raw {
                     content: "=",
                     position: (698, 46),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "value",
                      position: (698, 49),
                     },
                    },
                    Raw {
                     content: ")*",
                     position: (698, 55),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "scheme",
                     position: (699, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "id",
                      position: (699, 24),
                     },
                    },
                    Raw {
                     content: "(",
                     position: (699, 27),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "sep",
                      position: (699, 30),
                     },
                    },
                    Expression {
                     expression: Variable {
                      identifier: "options",
                      position: (699, 36),
                     },
                    },
                    Raw {
                     content: ")?",
                     position: (699, 44),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "content",
                     position: (700, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Expression {
                     expression: Variable {
                      identifier: "base64",
                      position: (700, 24),
                     },
                    },
                    Expression {
                     expression: Variable {
                      identifier: "sep",
                      position: (700, 33),
                     },
                    },
                    Expression {
                     expression: Variable {
                      identifier: "base64",
                      position: (700, 39),
                     },
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "mcf",
                     position: (701, 11),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "^",
                     position: (701, 18),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "sep",
                      position: (701, 21),
                     },
                    },
                    Expression {
                     expression: Variable {
                      identifier: "scheme",
                      position: (701, 27),
                     },
                    },
                    Expression {
                     expression: Variable {
                      identifier: "sep",
                      position: (701, 36),
                     },
                    },
                    Expression {
                     expression: Variable {
                      identifier: "content",
                      position: (701, 42),
                     },
                    },
                    Raw {
                     content: "$",
                     position: (701, 50),
                    },
                   ],
                  },
                 ),
                ],
                target: IfThenElse {
                 predicate: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "allowsLogin",
                       position: (703, 13),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "user",
                         position: (703, 25),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "hashedPassword",
                           position: (703, 30),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                     BinaryOperation {
                      operator: NotEqualTo,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "user",
                         position: (704, 16),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "hashedPassword",
                           position: (704, 21),
                          },
                         ],
                        },
                        default: None,
                       },
                       String {
                        parts: [],
                       },
                      ],
                      position: (704, 36),
                     },
                    ],
                    position: (704, 13),
                   },
                   BinaryOperation {
                    operator: EqualTo,
                    operands: [
                     FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "builtins",
                        position: (705, 16),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "match",
                          position: (705, 25),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Variable {
                        identifier: "mcf",
                        position: (705, 31),
                       },
                       PropertyAccess {
                        expression: Variable {
                         identifier: "user",
                         position: (705, 35),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "hashedPassword",
                           position: (705, 40),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                     Variable {
                      identifier: "null",
                      position: (705, 58),
                     },
                    ],
                    position: (705, 55),
                   },
                  ],
                  position: (705, 13),
                 },
                 then: String {
                  parts: [
                   Raw {
                    content: "          The password hash of user \"",
                    position: (707, 1),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "user",
                      position: (707, 40),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (707, 45),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\" may be invalid. You must set a\nvalid hash or the user will be locked out of their account. Please\ncheck the value of option `users.users.\"",
                    position: (707, 50),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "user",
                      position: (709, 53),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "name",
                        position: (709, 58),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: "\".hashedPassword`.",
                    position: (709, 63),
                   },
                  ],
                 },
                 else_: Variable {
                  identifier: "null",
                  position: (710, 14),
                 },
                 position: (703, 9),
                },
                position: (693, 9),
               },
               position: (684, 43),
              },
              position: (684, 40),
             },
            ],
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (539, 12),
      },
     ),
    ],
    recursive: false,
    position: (448, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}