---
Function {
 argument: Destructured {
  identifier: None,
  arguments: [
   DestructuredArgument {
    identifier: "config",
    default: None,
   },
   DestructuredArgument {
    identifier: "lib",
    default: None,
   },
   DestructuredArgument {
    identifier: "utils",
    default: None,
   },
   DestructuredArgument {
    identifier: "pkgs",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "ids",
        position: (6, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "ids",
         position: (6, 16),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "cfg",
        position: (7, 3),
       },
      ],
     },
     to: PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       parts: [
        Raw {
         content: "users",
         position: (7, 16),
        },
       ],
      },
      default: None,
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "isPasswdCompatible",
        position: (9, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "str",
      },
      definition: UnaryOperation {
       operator: Not,
       operand: Parentheses {
        expression: BinaryOperation {
         operator: LogicalOr,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "hasInfix",
            position: (9, 31),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: ":",
               position: (9, 41),
              },
             ],
             position: (9, 40),
            },
            Variable {
             identifier: "str",
             position: (9, 44),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "hasInfix",
            position: (9, 51),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (9, 61),
              },
             ],
             position: (9, 60),
            },
            Variable {
             identifier: "str",
             position: (9, 65),
            },
           ],
          },
         ],
         position: (9, 48),
        },
        position: (9, 30),
       },
       position: (9, 29),
      },
      position: (9, 24),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "passwdEntry",
        position: (10, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "type",
      },
      definition: BinaryOperation {
       operator: Update,
       operands: [
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (10, 23),
          },
          attribute_path: AttributePath {
           parts: [
            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: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "name",
              position: (11, 5),
             },
            ],
           },
           to: String {
            parts: [
             Raw {
              content: "passwdEntry ",
              position: (11, 13),
             },
             Interpolation {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (11, 27),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "name",
                  position: (11, 32),
                 },
                ],
               },
               default: None,
              },
             },
            ],
            position: (11, 12),
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "description",
              position: (12, 5),
             },
            ],
           },
           to: String {
            parts: [
             Interpolation {
              expression: PropertyAccess {
               expression: Variable {
                identifier: "type",
                position: (12, 22),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (12, 27),
                 },
                ],
               },
               default: None,
              },
             },
             Raw {
              content: ", not containing newlines or colons",
              position: (12, 39),
             },
            ],
            position: (12, 19),
           },
          },
         ],
         recursive: false,
         position: (10, 69),
        },
       ],
       position: (10, 66),
      },
      position: (10, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "allowsLogin",
        position: (16, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "hash",
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: EqualTo,
         operands: [
          Variable {
           identifier: "hash",
           position: (17, 5),
          },
          String {
           parts: [],
           position: (17, 13),
          },
         ],
         position: (17, 10),
        },
        UnaryOperation {
         operator: Not,
         operand: Parentheses {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (18, 10),
            },
            attribute_path: AttributePath {
             parts: [
              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),
                },
               ],
               position: (20, 9),
              },
              String {
               parts: [
                Raw {
                 content: "!!",
                 position: (21, 10),
                },
               ],
               position: (21, 9),
              },
              String {
               parts: [
                Raw {
                 content: "*",
                 position: (22, 10),
                },
               ],
               position: (22, 9),
              },
             ],
             position: (19, 7),
            },
           ],
          },
          position: (18, 9),
         },
         position: (18, 8),
        },
       ],
       position: (18, 5),
      },
      position: (16, 17),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "passwordDescription",
        position: (25, 3),
       },
      ],
     },
     to: 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),
       },
      ],
      position: (25, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "hashedPasswordDescription",
        position: (43, 3),
       },
      ],
     },
     to: 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),
       },
      ],
      position: (43, 31),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "userOpts",
        position: (58, 3),
       },
      ],
     },
     to: Function {
      argument: Destructured {
       identifier: None,
       arguments: [
        DestructuredArgument {
         identifier: "name",
         default: None,
        },
        DestructuredArgument {
         identifier: "config",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "options",
            position: (60, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (62, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (62, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (63, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (63, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (63, 28),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (63, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "apply",
                    position: (64, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "x",
                  },
                  definition: Assert {
                   expression: Parentheses {
                    expression: BinaryOperation {
                     operator: LogicalOr,
                     operands: [
                      BinaryOperation {
                       operator: LessThan,
                       operands: [
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "builtins",
                           position: (64, 28),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            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),
                          },
                          Interpolation {
                           expression: Variable {
                            identifier: "x",
                            position: (64, 79),
                           },
                          },
                          Raw {
                           content: "' is longer than 31 characters which is not allowed!",
                           position: (64, 81),
                          },
                         ],
                         position: (64, 66),
                        },
                       ],
                      },
                     ],
                     position: (64, 57),
                    },
                    position: (64, 27),
                   },
                   target: Variable {
                    identifier: "x",
                    position: (64, 137),
                   },
                   position: (64, 20),
                  },
                  position: (64, 17),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (65, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (65, 23),
                 },
                },
               ],
               recursive: false,
               position: (62, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "description",
               position: (71, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (71, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (72, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (72, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (72, 28),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (72, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (73, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [],
                  position: (73, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (74, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Alice Q. User",
                    position: (74, 20),
                   },
                  ],
                  position: (74, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (75, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (75, 23),
                 },
                },
               ],
               recursive: false,
               position: (71, 30),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "uid",
               position: (82, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (82, 13),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (83, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (84, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (84, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (85, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The account UID. If the UID is null, a free UID is picked on\nactivation.\n",
                    position: (86, 1),
                   },
                  ],
                  position: (85, 23),
                 },
                },
               ],
               recursive: false,
               position: (82, 22),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "isSystemUser",
               position: (91, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (91, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (92, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (92, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (92, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (93, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (93, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (94, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (94, 23),
                 },
                },
               ],
               recursive: false,
               position: (91, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "isNormalUser",
               position: (106, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (106, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (107, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (107, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (107, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (108, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (108, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (109, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (109, 23),
                 },
                },
               ],
               recursive: false,
               position: (106, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "group",
               position: (123, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (123, 15),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (124, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (124, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "str",
                     position: (124, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "apply",
                    position: (125, 9),
                   },
                  ],
                 },
                 to: Function {
                  argument: Simple {
                   identifier: "x",
                  },
                  definition: Assert {
                   expression: Parentheses {
                    expression: BinaryOperation {
                     operator: LogicalOr,
                     operands: [
                      BinaryOperation {
                       operator: LessThan,
                       operands: [
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "builtins",
                           position: (125, 28),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            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),
                          },
                          Interpolation {
                           expression: Variable {
                            identifier: "x",
                            position: (125, 81),
                           },
                          },
                          Raw {
                           content: "' is longer than 31 characters which is not allowed!",
                           position: (125, 83),
                          },
                         ],
                         position: (125, 66),
                        },
                       ],
                      },
                     ],
                     position: (125, 57),
                    },
                    position: (125, 27),
                   },
                   target: Variable {
                    identifier: "x",
                    position: (125, 139),
                   },
                   position: (125, 20),
                  },
                  position: (125, 17),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (126, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [],
                  position: (126, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (127, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The user's primary group.",
                    position: (127, 24),
                   },
                  ],
                  position: (127, 23),
                 },
                },
               ],
               recursive: false,
               position: (123, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "extraGroups",
               position: (130, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (130, 21),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (131, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (131, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (131, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (131, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (131, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (132, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (132, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (133, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The user's auxiliary groups.",
                    position: (133, 24),
                   },
                  ],
                  position: (133, 23),
                 },
                },
               ],
               recursive: false,
               position: (130, 30),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "home",
               position: (136, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (136, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (137, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (137, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (137, 28),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "path",
                       position: (137, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (138, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "/var/empty",
                    position: (138, 20),
                   },
                  ],
                  position: (138, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (139, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The user's home directory.",
                    position: (139, 24),
                   },
                  ],
                  position: (139, 23),
                 },
                },
               ],
               recursive: false,
               position: (136, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "cryptHomeLuks",
               position: (142, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (142, 23),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (143, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (144, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (144, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (145, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Path to encrypted luks device that contains\nthe user's home directory.\n",
                    position: (146, 1),
                   },
                  ],
                  position: (145, 23),
                 },
                },
               ],
               recursive: false,
               position: (142, 32),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "pamMount",
               position: (151, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (151, 18),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (152, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (153, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (153, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (154, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (154, 23),
                 },
                },
               ],
               recursive: false,
               position: (151, 27),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "shell",
               position: (165, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (165, 15),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (166, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (166, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "nullOr",
                      position: (166, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Parentheses {
                    expression: FunctionApplication {
                     function: PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (166, 30),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "either",
                         position: (166, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (166, 43),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "shellPackage",
                          position: (166, 49),
                         },
                        ],
                       },
                       default: None,
                      },
                      Parentheses {
                       expression: FunctionApplication {
                        function: Variable {
                         identifier: "passwdEntry",
                         position: (166, 63),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "types",
                           position: (166, 75),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "path",
                             position: (166, 81),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                       },
                       position: (166, 62),
                      },
                     ],
                    },
                    position: (166, 29),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (167, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (167, 19),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "shadow",
                     position: (167, 24),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "defaultText",
                    position: (168, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (168, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.shadow",
                      position: (168, 42),
                     },
                    ],
                    position: (168, 41),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (169, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (169, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.bashInteractive",
                      position: (169, 38),
                     },
                    ],
                    position: (169, 37),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (170, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (170, 23),
                 },
                },
               ],
               recursive: false,
               position: (165, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "subUidRanges",
               position: (179, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (179, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (180, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (180, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (180, 28),
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "submodule",
                       position: (180, 36),
                      },
                      arguments: [
                       Variable {
                        identifier: "subordinateUidRange",
                        position: (180, 46),
                       },
                      ],
                     },
                     position: (180, 35),
                    },
                   ],
                  },
                  position: (180, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (181, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (181, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (182, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "startUid",
                         position: (183, 13),
                        },
                       ],
                      },
                      to: Int {
                       value: 1000,
                       position: (183, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "count",
                         position: (183, 30),
                        },
                       ],
                      },
                      to: Int {
                       value: 1,
                       position: (183, 38),
                      },
                     },
                    ],
                    recursive: false,
                    position: (183, 11),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "startUid",
                         position: (184, 13),
                        },
                       ],
                      },
                      to: Int {
                       value: 100001,
                       position: (184, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "count",
                         position: (184, 32),
                        },
                       ],
                      },
                      to: Int {
                       value: 65534,
                       position: (184, 40),
                      },
                     },
                    ],
                    recursive: false,
                    position: (184, 11),
                   },
                  ],
                  position: (182, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (186, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (186, 23),
                 },
                },
               ],
               recursive: false,
               position: (179, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "subGidRanges",
               position: (193, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (193, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (194, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (194, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (194, 28),
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "submodule",
                       position: (194, 36),
                      },
                      arguments: [
                       Variable {
                        identifier: "subordinateGidRange",
                        position: (194, 46),
                       },
                      ],
                     },
                     position: (194, 35),
                    },
                   ],
                  },
                  position: (194, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (195, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (195, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (196, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "startGid",
                         position: (197, 13),
                        },
                       ],
                      },
                      to: Int {
                       value: 100,
                       position: (197, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "count",
                         position: (197, 29),
                        },
                       ],
                      },
                      to: Int {
                       value: 1,
                       position: (197, 37),
                      },
                     },
                    ],
                    recursive: false,
                    position: (197, 11),
                   },
                   Map {
                    bindings: [
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "startGid",
                         position: (198, 13),
                        },
                       ],
                      },
                      to: Int {
                       value: 1001,
                       position: (198, 24),
                      },
                     },
                     Binding {
                      from: AttributePath {
                       parts: [
                        Raw {
                         content: "count",
                         position: (198, 30),
                        },
                       ],
                      },
                      to: Int {
                       value: 999,
                       position: (198, 38),
                      },
                     },
                    ],
                    recursive: false,
                    position: (198, 11),
                   },
                  ],
                  position: (196, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (200, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (200, 23),
                 },
                },
               ],
               recursive: false,
               position: (193, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "autoSubUidGidRange",
               position: (207, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (207, 28),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (208, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (208, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (208, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (209, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (209, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (210, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "true",
                  position: (210, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (211, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (211, 23),
                 },
                },
               ],
               recursive: false,
               position: (207, 37),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "createHome",
               position: (217, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (217, 20),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (218, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (218, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (218, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (219, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (219, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (220, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (220, 23),
                 },
                },
               ],
               recursive: false,
               position: (217, 29),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "useDefaultShell",
               position: (226, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (226, 25),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (227, 9),
                   },
                  ],
                 },
                 to: PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (227, 16),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "bool",
                     position: (227, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (228, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "false",
                  position: (228, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (229, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "If true, the user's shell will be set to\n<option>users.defaultUserShell</option>.\n",
                    position: (230, 1),
                   },
                  ],
                  position: (229, 23),
                 },
                },
               ],
               recursive: false,
               position: (226, 34),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "hashedPassword",
               position: (235, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (235, 24),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (236, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (236, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (236, 28),
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "passwdEntry",
                       position: (236, 36),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (236, 48),
                       },
                      ],
                     },
                     position: (236, 35),
                    },
                   ],
                  },
                  position: (236, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (237, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (237, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (238, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "Specifies the hashed password for the user.\n",
                    position: (239, 1),
                   },
                   Interpolation {
                    expression: Variable {
                     identifier: "passwordDescription",
                     position: (240, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (240, 33),
                   },
                   Interpolation {
                    expression: Variable {
                     identifier: "hashedPasswordDescription",
                     position: (241, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (241, 39),
                   },
                  ],
                  position: (238, 23),
                 },
                },
               ],
               recursive: false,
               position: (235, 33),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "password",
               position: (245, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (245, 18),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (246, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (247, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (247, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (248, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                   Interpolation {
                    expression: Variable {
                     identifier: "passwordDescription",
                     position: (253, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (253, 33),
                   },
                  ],
                  position: (248, 23),
                 },
                },
               ],
               recursive: false,
               position: (245, 27),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "passwordFile",
               position: (257, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (257, 22),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (258, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (259, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (259, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (260, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                   Interpolation {
                    expression: Variable {
                     identifier: "passwordDescription",
                     position: (265, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (265, 33),
                   },
                  ],
                  position: (260, 23),
                 },
                },
               ],
               recursive: false,
               position: (257, 31),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "initialHashedPassword",
               position: (269, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (269, 31),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (270, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (270, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (270, 28),
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "passwdEntry",
                       position: (270, 36),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (270, 48),
                       },
                      ],
                     },
                     position: (270, 35),
                    },
                   ],
                  },
                  position: (270, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (271, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (271, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (272, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                   Interpolation {
                    expression: Variable {
                     identifier: "hashedPasswordDescription",
                     position: (280, 13),
                    },
                   },
                   Raw {
                    content: "\n",
                    position: (280, 39),
                   },
                  ],
                  position: (272, 23),
                 },
                },
               ],
               recursive: false,
               position: (269, 40),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "initialPassword",
               position: (284, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (284, 25),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (285, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (286, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (286, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (287, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (287, 23),
                 },
                },
               ],
               recursive: false,
               position: (284, 34),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "packages",
               position: (301, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (301, 18),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (302, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (302, 16),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "listOf",
                      position: (302, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (302, 29),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "package",
                       position: (302, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (303, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (303, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "example",
                    position: (304, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (304, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "[ pkgs.firefox pkgs.thunderbird ]",
                      position: (304, 38),
                     },
                    ],
                    position: (304, 37),
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (305, 9),
                   },
                  ],
                 },
                 to: 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),
                   },
                  ],
                  position: (305, 23),
                 },
                },
               ],
               recursive: false,
               position: (301, 27),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (60, 15),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "config",
            position: (314, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkMerge",
           position: (314, 14),
          },
          arguments: [
           List {
            elements: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "name",
                   position: (315, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkDefault",
                  position: (315, 18),
                 },
                 arguments: [
                  Variable {
                   identifier: "name",
                   position: (315, 28),
                  },
                 ],
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "shell",
                   position: (316, 11),
                  },
                 ],
                },
                to: FunctionApplication {
                 function: Variable {
                  identifier: "mkIf",
                  position: (316, 19),
                 },
                 arguments: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (316, 24),
                   },
                   attribute_path: AttributePath {
                    parts: [
                     Raw {
                      content: "useDefaultShell",
                      position: (316, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                  Parentheses {
                   expression: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (316, 48),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (316, 58),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "defaultUserShell",
                         position: (316, 62),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                   position: (316, 47),
                  },
                 ],
                },
               },
              ],
              recursive: false,
              position: (315, 9),
             },
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (318, 10),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (318, 15),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "isNormalUser",
                    position: (318, 22),
                   },
                  ],
                 },
                 default: None,
                },
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "group",
                      position: (319, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (319, 19),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "users",
                        position: (319, 30),
                       },
                      ],
                      position: (319, 29),
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "createHome",
                      position: (320, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (320, 24),
                    },
                    arguments: [
                     Variable {
                      identifier: "true",
                      position: (320, 34),
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "home",
                      position: (321, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (321, 18),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "/home/",
                        position: (321, 29),
                       },
                       Interpolation {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (321, 37),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "name",
                            position: (321, 44),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                      ],
                      position: (321, 28),
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "useDefaultShell",
                      position: (322, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (322, 29),
                    },
                    arguments: [
                     Variable {
                      identifier: "true",
                      position: (322, 39),
                     },
                    ],
                   },
                  },
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "isSystemUser",
                      position: (323, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (323, 26),
                    },
                    arguments: [
                     Variable {
                      identifier: "false",
                      position: (323, 36),
                     },
                    ],
                   },
                  },
                 ],
                 recursive: false,
                 position: (318, 35),
                },
               ],
              },
              position: (318, 9),
             },
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (327, 10),
               },
               arguments: [
                Parentheses {
                 expression: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   UnaryOperation {
                    operator: Not,
                    operand: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (327, 17),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       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 {
                       parts: [
                        Raw {
                         content: "initialPassword",
                         position: (327, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (327, 63),
                     },
                    ],
                    position: (327, 60),
                   },
                  ],
                  position: (327, 34),
                 },
                 position: (327, 15),
                },
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "password",
                      position: (328, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (328, 22),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (328, 32),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "initialPassword",
                         position: (328, 39),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                 ],
                 recursive: false,
                 position: (327, 69),
                },
               ],
              },
              position: (327, 9),
             },
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (330, 10),
               },
               arguments: [
                Parentheses {
                 expression: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   UnaryOperation {
                    operator: Not,
                    operand: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (330, 17),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       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 {
                       parts: [
                        Raw {
                         content: "initialHashedPassword",
                         position: (330, 44),
                        },
                       ],
                      },
                      default: None,
                     },
                     Variable {
                      identifier: "null",
                      position: (330, 69),
                     },
                    ],
                    position: (330, 66),
                   },
                  ],
                  position: (330, 34),
                 },
                 position: (330, 15),
                },
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "hashedPassword",
                      position: (331, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (331, 28),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (331, 38),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "initialHashedPassword",
                         position: (331, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  },
                 ],
                 recursive: false,
                 position: (330, 75),
                },
               ],
              },
              position: (330, 9),
             },
             Parentheses {
              expression: FunctionApplication {
               function: Variable {
                identifier: "mkIf",
                position: (333, 10),
               },
               arguments: [
                Parentheses {
                 expression: BinaryOperation {
                  operator: LogicalAnd,
                  operands: [
                   BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (333, 16),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "isNormalUser",
                         position: (333, 23),
                        },
                       ],
                      },
                      default: None,
                     },
                     BinaryOperation {
                      operator: EqualTo,
                      operands: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (333, 39),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          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 {
                       parts: [
                        Raw {
                         content: "subGidRanges",
                         position: (333, 75),
                        },
                       ],
                      },
                      default: None,
                     },
                     List {
                      elements: [],
                      position: (333, 91),
                     },
                    ],
                    position: (333, 88),
                   },
                  ],
                  position: (333, 65),
                 },
                 position: (333, 15),
                },
                Map {
                 bindings: [
                  Binding {
                   from: AttributePath {
                    parts: [
                     Raw {
                      content: "autoSubUidGidRange",
                      position: (334, 11),
                     },
                    ],
                   },
                   to: FunctionApplication {
                    function: Variable {
                     identifier: "mkDefault",
                     position: (334, 32),
                    },
                    arguments: [
                     Variable {
                      identifier: "true",
                      position: (334, 42),
                     },
                    ],
                   },
                  },
                 ],
                 recursive: false,
                 position: (333, 95),
                },
               ],
              },
              position: (333, 9),
             },
            ],
            position: (315, 7),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (58, 37),
      },
      position: (58, 14),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "groupOpts",
        position: (340, 3),
       },
      ],
     },
     to: Function {
      argument: Destructured {
       identifier: None,
       arguments: [
        DestructuredArgument {
         identifier: "name",
         default: None,
        },
        DestructuredArgument {
         identifier: "config",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "options",
            position: (342, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (344, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (344, 14),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (345, 9),
                   },
                  ],
                 },
                 to: FunctionApplication {
                  function: Variable {
                   identifier: "passwdEntry",
                   position: (345, 16),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (345, 28),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "str",
                       position: (345, 34),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (346, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The name of the group. If undefined, the name of the attribute set\nwill be used.\n",
                    position: (347, 1),
                   },
                  ],
                  position: (346, 23),
                 },
                },
               ],
               recursive: false,
               position: (344, 23),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "gid",
               position: (352, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (352, 13),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (353, 9),
                   },
                  ],
                 },
                 to: 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),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (354, 9),
                   },
                  ],
                 },
                 to: Variable {
                  identifier: "null",
                  position: (354, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (355, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The group GID. If the GID is null, a free GID is picked on\nactivation.\n",
                    position: (356, 1),
                   },
                  ],
                  position: (355, 23),
                 },
                },
               ],
               recursive: false,
               position: (352, 22),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "members",
               position: (361, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (361, 17),
             },
             arguments: [
              Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "type",
                    position: (362, 9),
                   },
                  ],
                 },
                 to: With {
                  expression: Variable {
                   identifier: "types",
                   position: (362, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "listOf",
                    position: (362, 28),
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: Variable {
                       identifier: "passwdEntry",
                       position: (362, 36),
                      },
                      arguments: [
                       Variable {
                        identifier: "str",
                        position: (362, 48),
                       },
                      ],
                     },
                     position: (362, 35),
                    },
                   ],
                  },
                  position: (362, 16),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "default",
                    position: (363, 9),
                   },
                  ],
                 },
                 to: List {
                  elements: [],
                  position: (363, 19),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "description",
                    position: (364, 9),
                   },
                  ],
                 },
                 to: String {
                  parts: [
                   Raw {
                    content: "The user names of the group members, added to the\n<literal>/etc/group</literal> file.\n",
                    position: (365, 1),
                   },
                  ],
                  position: (364, 23),
                 },
                },
               ],
               recursive: false,
               position: (361, 26),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (342, 15),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "config",
            position: (372, 5),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "name",
               position: (373, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mkDefault",
              position: (373, 14),
             },
             arguments: [
              Variable {
               identifier: "name",
               position: (373, 24),
              },
             ],
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "members",
               position: (375, 7),
              },
             ],
            },
            to: FunctionApplication {
             function: Variable {
              identifier: "mapAttrsToList",
              position: (375, 17),
             },
             arguments: [
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "n",
                },
                definition: Function {
                 argument: Simple {
                  identifier: "u",
                 },
                 definition: PropertyAccess {
                  expression: Variable {
                   identifier: "u",
                   position: (375, 39),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "name",
                     position: (375, 41),
                    },
                   ],
                  },
                  default: None,
                 },
                 position: (375, 36),
                },
                position: (375, 33),
               },
               position: (375, 32),
              },
              Parentheses {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "filterAttrs",
                 position: (376, 9),
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "n",
                   },
                   definition: Function {
                    argument: Simple {
                     identifier: "u",
                    },
                    definition: FunctionApplication {
                     function: Variable {
                      identifier: "elem",
                      position: (376, 28),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "config",
                        position: (376, 33),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "name",
                          position: (376, 40),
                         },
                        ],
                       },
                       default: None,
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "u",
                        position: (376, 45),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "extraGroups",
                          position: (376, 47),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                    position: (376, 25),
                   },
                   position: (376, 22),
                  },
                  position: (376, 21),
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (376, 60),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "users",
                     position: (376, 64),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               position: (375, 47),
              },
             ],
            },
           },
          ],
          recursive: false,
          position: (372, 14),
         },
        },
       ],
       recursive: false,
       position: (340, 38),
      },
      position: (340, 15),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "subordinateUidRange",
        position: (382, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "options",
           position: (383, 5),
          },
         ],
        },
        to: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "startUid",
              position: (384, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (384, 18),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (385, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (385, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "int",
                    position: (385, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (386, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "Start of the range of subordinate user ids that user is\nallowed to use.\n",
                   position: (387, 1),
                  },
                 ],
                 position: (386, 23),
                },
               },
              ],
              recursive: false,
              position: (384, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "count",
              position: (391, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (391, 15),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (392, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (392, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "int",
                    position: (392, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (393, 9),
                  },
                 ],
                },
                to: Int {
                 value: 1,
                 position: (393, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (394, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "Count of subordinate user ids",
                   position: (394, 24),
                  },
                 ],
                 position: (394, 23),
                },
               },
              ],
              recursive: false,
              position: (391, 24),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (383, 15),
        },
       },
      ],
      recursive: false,
      position: (382, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "subordinateGidRange",
        position: (399, 3),
       },
      ],
     },
     to: Map {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "options",
           position: (400, 5),
          },
         ],
        },
        to: Map {
         bindings: [
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "startGid",
              position: (401, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (401, 18),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (402, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (402, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "int",
                    position: (402, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (403, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "Start of the range of subordinate group ids that user is\nallowed to use.\n",
                   position: (404, 1),
                  },
                 ],
                 position: (403, 23),
                },
               },
              ],
              recursive: false,
              position: (401, 27),
             },
            ],
           },
          },
          Binding {
           from: AttributePath {
            parts: [
             Raw {
              content: "count",
              position: (408, 7),
             },
            ],
           },
           to: FunctionApplication {
            function: Variable {
             identifier: "mkOption",
             position: (408, 15),
            },
            arguments: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "type",
                   position: (409, 9),
                  },
                 ],
                },
                to: PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (409, 16),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "int",
                    position: (409, 22),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "default",
                   position: (410, 9),
                  },
                 ],
                },
                to: Int {
                 value: 1,
                 position: (410, 19),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "description",
                   position: (411, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "Count of subordinate group ids",
                   position: (411, 24),
                  },
                 ],
                 position: (411, 23),
                },
               },
              ],
              recursive: false,
              position: (408, 24),
             },
            ],
           },
          },
         ],
         recursive: false,
         position: (400, 15),
        },
       },
      ],
      recursive: false,
      position: (399, 25),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "idsAreUnique",
        position: (416, 3),
       },
      ],
     },
     to: Function {
      argument: Simple {
       identifier: "set",
      },
      definition: Function {
       argument: Simple {
        identifier: "idAttr",
       },
       definition: UnaryOperation {
        operator: Not,
        operand: PropertyAccess {
         expression: Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "foldr",
            position: (416, 33),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "name",
              },
              definition: Function {
               argument: Destructured {
                identifier: LeftAt(
                 "args",
                ),
                arguments: [
                 DestructuredArgument {
                  identifier: "dup",
                  default: None,
                 },
                 DestructuredArgument {
                  identifier: "acc",
                  default: None,
                 },
                ],
                ellipsis: false,
               },
               definition: LetIn {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "id",
                     position: (418, 7),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (418, 12),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "toString",
                       position: (418, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Parentheses {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "builtins",
                        position: (418, 31),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "getAttr",
                          position: (418, 40),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       Variable {
                        identifier: "idAttr",
                        position: (418, 48),
                       },
                       Parentheses {
                        expression: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "builtins",
                           position: (418, 56),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            Raw {
                             content: "getAttr",
                             position: (418, 65),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Variable {
                           identifier: "name",
                           position: (418, 73),
                          },
                          Variable {
                           identifier: "set",
                           position: (418, 78),
                          },
                         ],
                        },
                        position: (418, 55),
                       },
                      ],
                     },
                     position: (418, 30),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "exists",
                     position: (419, 7),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "builtins",
                     position: (419, 16),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "hasAttr",
                       position: (419, 25),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Variable {
                     identifier: "id",
                     position: (419, 33),
                    },
                    Variable {
                     identifier: "acc",
                     position: (419, 36),
                    },
                   ],
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "newAcc",
                     position: (420, 7),
                    },
                   ],
                  },
                  to: BinaryOperation {
                   operator: Update,
                   operands: [
                    Variable {
                     identifier: "acc",
                     position: (420, 16),
                    },
                    Parentheses {
                     expression: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "builtins",
                        position: (420, 24),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "listToAttrs",
                          position: (420, 33),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       List {
                        elements: [
                         Map {
                          bindings: [
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (420, 49),
                              },
                             ],
                            },
                            to: Variable {
                             identifier: "id",
                             position: (420, 56),
                            },
                           },
                           Binding {
                            from: AttributePath {
                             parts: [
                              Raw {
                               content: "value",
                               position: (420, 60),
                              },
                             ],
                            },
                            to: Variable {
                             identifier: "true",
                             position: (420, 68),
                            },
                           },
                          ],
                          recursive: false,
                          position: (420, 47),
                         },
                        ],
                        position: (420, 45),
                       },
                      ],
                     },
                     position: (420, 23),
                    },
                   ],
                   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 {
                     parts: [
                      Raw {
                       content: "trace",
                       position: (422, 21),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "Duplicate ",
                       position: (422, 28),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "idAttr",
                        position: (422, 40),
                       },
                      },
                      Raw {
                       content: " ",
                       position: (422, 47),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "id",
                        position: (422, 50),
                       },
                      },
                     ],
                     position: (422, 27),
                    },
                    Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "dup",
                          position: (422, 57),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "true",
                        position: (422, 63),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "acc",
                          position: (422, 69),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "null",
                        position: (422, 75),
                       },
                      },
                     ],
                     recursive: false,
                     position: (422, 55),
                    },
                   ],
                  },
                  else_: Map {
                   bindings: [
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "dup",
                        position: (423, 14),
                       },
                      ],
                     },
                     to: Variable {
                      identifier: "false",
                      position: (423, 20),
                     },
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "acc",
                        position: (423, 27),
                       },
                      ],
                     },
                     to: 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),
             },
             position: (416, 39),
            },
            Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "dup",
                  position: (424, 9),
                 },
                ],
               },
               to: Variable {
                identifier: "false",
                position: (424, 15),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "acc",
                  position: (424, 22),
                 },
                ],
               },
               to: Map {
                bindings: [],
                recursive: false,
                position: (424, 28),
               },
              },
             ],
             recursive: false,
             position: (424, 7),
            },
            Parentheses {
             expression: FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "builtins",
                position: (424, 35),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "attrNames",
                  position: (424, 44),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "set",
                position: (424, 54),
               },
              ],
             },
             position: (424, 34),
            },
           ],
          },
          position: (416, 32),
         },
         attribute_path: AttributePath {
          parts: [
           Raw {
            content: "dup",
            position: (424, 60),
           },
          ],
         },
         default: None,
        },
        position: (416, 31),
       },
       position: (416, 23),
      },
      position: (416, 18),
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "uidsAreUnique",
        position: (426, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "idsAreUnique",
       position: (426, 19),
      },
      arguments: [
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "filterAttrs",
          position: (426, 33),
         },
         arguments: [
          Parentheses {
           expression: Function {
            argument: Simple {
             identifier: "n",
            },
            definition: Function {
             argument: Simple {
              identifier: "u",
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "u",
                 position: (426, 52),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "uid",
                   position: (426, 54),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (426, 61),
               },
              ],
              position: (426, 58),
             },
             position: (426, 49),
            },
            position: (426, 46),
           },
           position: (426, 45),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (426, 67),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "users",
              position: (426, 71),
             },
            ],
           },
           default: None,
          },
         ],
        },
        position: (426, 32),
       },
       String {
        parts: [
         Raw {
          content: "uid",
          position: (426, 79),
         },
        ],
        position: (426, 78),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "gidsAreUnique",
        position: (427, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: Variable {
       identifier: "idsAreUnique",
       position: (427, 19),
      },
      arguments: [
       Parentheses {
        expression: FunctionApplication {
         function: Variable {
          identifier: "filterAttrs",
          position: (427, 33),
         },
         arguments: [
          Parentheses {
           expression: Function {
            argument: Simple {
             identifier: "n",
            },
            definition: Function {
             argument: Simple {
              identifier: "g",
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "g",
                 position: (427, 52),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "gid",
                   position: (427, 54),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (427, 61),
               },
              ],
              position: (427, 58),
             },
             position: (427, 49),
            },
            position: (427, 46),
           },
           position: (427, 45),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (427, 67),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "groups",
              position: (427, 71),
             },
            ],
           },
           default: None,
          },
         ],
        },
        position: (427, 32),
       },
       String {
        parts: [
         Raw {
          content: "gid",
          position: (427, 80),
         },
        ],
        position: (427, 79),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "spec",
        position: (429, 3),
       },
      ],
     },
     to: FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (429, 10),
       },
       attribute_path: AttributePath {
        parts: [
         Raw {
          content: "writeText",
          position: (429, 15),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "users-groups.json",
          position: (429, 26),
         },
        ],
        position: (429, 25),
       },
       Parentheses {
        expression: FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "builtins",
           position: (429, 46),
          },
          attribute_path: AttributePath {
           parts: [
            Raw {
             content: "toJSON",
             position: (429, 55),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Map {
           bindings: [
            Inherit {
             from: Some(
              Variable {
               identifier: "cfg",
               position: (430, 14),
              },
             ),
             attributes: [
              Raw {
               content: "mutableUsers",
               position: (430, 19),
              },
             ],
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "users",
                position: (431, 5),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "mapAttrsToList",
               position: (431, 13),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "_",
                 },
                 definition: Function {
                  argument: Simple {
                   identifier: "u",
                  },
                  definition: Map {
                   bindings: [
                    Inherit {
                     from: Some(
                      Variable {
                       identifier: "u",
                       position: (432, 18),
                      },
                     ),
                     attributes: [
                      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),
                      },
                     ],
                    },
                    Binding {
                     from: AttributePath {
                      parts: [
                       Raw {
                        content: "shell",
                        position: (437, 9),
                       },
                      ],
                     },
                     to: FunctionApplication {
                      function: PropertyAccess {
                       expression: Variable {
                        identifier: "utils",
                        position: (437, 17),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "toShellPath",
                          position: (437, 23),
                         },
                        ],
                       },
                       default: None,
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "u",
                         position: (437, 35),
                        },
                        attribute_path: AttributePath {
                         parts: [
                          Raw {
                           content: "shell",
                           position: (437, 37),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                     },
                    },
                   ],
                   recursive: false,
                   position: (432, 7),
                  },
                  position: (431, 32),
                 },
                 position: (431, 29),
                },
                position: (431, 28),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (438, 10),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "users",
                   position: (438, 14),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            },
            Binding {
             from: AttributePath {
              parts: [
               Raw {
                content: "groups",
                position: (439, 5),
               },
              ],
             },
             to: FunctionApplication {
              function: Variable {
               identifier: "attrValues",
               position: (439, 14),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (439, 25),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "groups",
                   position: (439, 29),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
            },
           ],
           recursive: false,
           position: (429, 62),
          },
         ],
        },
        position: (429, 45),
       },
      ],
     },
    },
    Binding {
     from: AttributePath {
      parts: [
       Raw {
        content: "systemShells",
        position: (442, 3),
       },
      ],
     },
     to: LetIn {
      bindings: [
       Binding {
        from: AttributePath {
         parts: [
          Raw {
           content: "shells",
           position: (444, 7),
          },
         ],
        },
        to: FunctionApplication {
         function: Variable {
          identifier: "mapAttrsToList",
          position: (444, 16),
         },
         arguments: [
          Parentheses {
           expression: Function {
            argument: Simple {
             identifier: "_",
            },
            definition: Function {
             argument: Simple {
              identifier: "u",
             },
             definition: PropertyAccess {
              expression: Variable {
               identifier: "u",
               position: (444, 38),
              },
              attribute_path: AttributePath {
               parts: [
                Raw {
                 content: "shell",
                 position: (444, 40),
                },
               ],
              },
              default: None,
             },
             position: (444, 35),
            },
            position: (444, 32),
           },
           position: (444, 31),
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (444, 47),
           },
           attribute_path: AttributePath {
            parts: [
             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 {
          parts: [
           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: [
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "imports",
         position: (449, 3),
        },
       ],
      },
      to: List {
       elements: [
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "mkAliasOptionModule",
           position: (450, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (450, 29),
               },
              ],
              position: (450, 28),
             },
             String {
              parts: [
               Raw {
                content: "extraUsers",
                position: (450, 37),
               },
              ],
              position: (450, 36),
             },
            ],
            position: (450, 26),
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (450, 54),
               },
              ],
              position: (450, 53),
             },
             String {
              parts: [
               Raw {
                content: "users",
                position: (450, 62),
               },
              ],
              position: (450, 61),
             },
            ],
            position: (450, 51),
           },
          ],
         },
         position: (450, 5),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "mkAliasOptionModule",
           position: (451, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (451, 29),
               },
              ],
              position: (451, 28),
             },
             String {
              parts: [
               Raw {
                content: "extraGroups",
                position: (451, 37),
               },
              ],
              position: (451, 36),
             },
            ],
            position: (451, 26),
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (451, 55),
               },
              ],
              position: (451, 54),
             },
             String {
              parts: [
               Raw {
                content: "groups",
                position: (451, 63),
               },
              ],
              position: (451, 62),
             },
            ],
            position: (451, 52),
           },
          ],
         },
         position: (451, 5),
        },
        Parentheses {
         expression: FunctionApplication {
          function: Variable {
           identifier: "mkRenamedOptionModule",
           position: (452, 6),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "security",
                position: (452, 30),
               },
              ],
              position: (452, 29),
             },
             String {
              parts: [
               Raw {
                content: "initialRootPassword",
                position: (452, 41),
               },
              ],
              position: (452, 40),
             },
            ],
            position: (452, 28),
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (452, 65),
               },
              ],
              position: (452, 64),
             },
             String {
              parts: [
               Raw {
                content: "users",
                position: (452, 73),
               },
              ],
              position: (452, 72),
             },
             String {
              parts: [
               Raw {
                content: "root",
                position: (452, 81),
               },
              ],
              position: (452, 80),
             },
             String {
              parts: [
               Raw {
                content: "initialHashedPassword",
                position: (452, 88),
               },
              ],
              position: (452, 87),
             },
            ],
            position: (452, 63),
           },
          ],
         },
         position: (452, 5),
        },
       ],
       position: (449, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "options",
         position: (456, 3),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (458, 5),
           },
           Raw {
            content: "mutableUsers",
            position: (458, 11),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (458, 26),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (459, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (459, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "bool",
                  position: (459, 20),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (460, 7),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (460, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (461, 7),
                },
               ],
              },
              to: 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),
                },
               ],
               position: (461, 21),
              },
             },
            ],
            recursive: false,
            position: (458, 35),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (483, 5),
           },
           Raw {
            content: "enforceIdUniqueness",
            position: (483, 11),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (483, 33),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (484, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (484, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "bool",
                  position: (484, 20),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (485, 7),
                },
               ],
              },
              to: Variable {
               identifier: "true",
               position: (485, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (486, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Whether to require that no two users/groups share the same uid/gid.\n",
                 position: (487, 1),
                },
               ],
               position: (486, 21),
              },
             },
            ],
            recursive: false,
            position: (483, 42),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (491, 5),
           },
           Raw {
            content: "users",
            position: (491, 11),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (491, 19),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (492, 7),
                },
               ],
              },
              to: Map {
               bindings: [],
               recursive: false,
               position: (492, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (493, 7),
                },
               ],
              },
              to: With {
               expression: Variable {
                identifier: "types",
                position: (493, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (493, 26),
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "submodule",
                    position: (493, 35),
                   },
                   arguments: [
                    Variable {
                     identifier: "userOpts",
                     position: (493, 45),
                    },
                   ],
                  },
                  position: (493, 34),
                 },
                ],
               },
               position: (493, 14),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (494, 7),
                },
               ],
              },
              to: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "alice",
                    position: (495, 9),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "uid",
                       position: (496, 11),
                      },
                     ],
                    },
                    to: Int {
                     value: 1234,
                     position: (496, 17),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "description",
                       position: (497, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "Alice Q. User",
                       position: (497, 26),
                      },
                     ],
                     position: (497, 25),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "home",
                       position: (498, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "/home/alice",
                       position: (498, 19),
                      },
                     ],
                     position: (498, 18),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "createHome",
                       position: (499, 11),
                      },
                     ],
                    },
                    to: Variable {
                     identifier: "true",
                     position: (499, 24),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "group",
                       position: (500, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "users",
                       position: (500, 20),
                      },
                     ],
                     position: (500, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "extraGroups",
                       position: (501, 11),
                      },
                     ],
                    },
                    to: List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "wheel",
                         position: (501, 27),
                        },
                       ],
                       position: (501, 26),
                      },
                     ],
                     position: (501, 25),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "shell",
                       position: (502, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "/bin/sh",
                       position: (502, 20),
                      },
                     ],
                     position: (502, 19),
                    },
                   },
                  ],
                  recursive: false,
                  position: (495, 17),
                 },
                },
               ],
               recursive: false,
               position: (494, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (505, 7),
                },
               ],
              },
              to: 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),
                },
               ],
               position: (505, 21),
              },
             },
            ],
            recursive: false,
            position: (491, 28),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (511, 5),
           },
           Raw {
            content: "groups",
            position: (511, 11),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (511, 20),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (512, 7),
                },
               ],
              },
              to: Map {
               bindings: [],
               recursive: false,
               position: (512, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "example",
                 position: (513, 7),
                },
               ],
              },
              to: Map {
               bindings: [
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "students",
                    position: (514, 11),
                   },
                   Raw {
                    content: "gid",
                    position: (514, 20),
                   },
                  ],
                 },
                 to: Int {
                  value: 1001,
                  position: (514, 26),
                 },
                },
                Binding {
                 from: AttributePath {
                  parts: [
                   Raw {
                    content: "hackers",
                    position: (515, 11),
                   },
                  ],
                 },
                 to: Map {
                  bindings: [],
                  recursive: false,
                  position: (515, 21),
                 },
                },
               ],
               recursive: false,
               position: (514, 9),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (517, 7),
                },
               ],
              },
              to: With {
               expression: Variable {
                identifier: "types",
                position: (517, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (517, 26),
                },
                arguments: [
                 Parentheses {
                  expression: FunctionApplication {
                   function: Variable {
                    identifier: "submodule",
                    position: (517, 35),
                   },
                   arguments: [
                    Variable {
                     identifier: "groupOpts",
                     position: (517, 45),
                    },
                   ],
                  },
                  position: (517, 34),
                 },
                ],
               },
               position: (517, 14),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (518, 7),
                },
               ],
              },
              to: String {
               parts: [
                Raw {
                 content: "Additional groups to be created automatically by the system.\n",
                 position: (519, 1),
                },
               ],
               position: (518, 21),
              },
             },
            ],
            recursive: false,
            position: (511, 29),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (524, 5),
           },
           Raw {
            content: "allowNoPasswordLogin",
            position: (524, 11),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (524, 34),
          },
          arguments: [
           Map {
            bindings: [
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "type",
                 position: (525, 7),
                },
               ],
              },
              to: PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (525, 14),
               },
               attribute_path: AttributePath {
                parts: [
                 Raw {
                  content: "bool",
                  position: (525, 20),
                 },
                ],
               },
               default: None,
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "default",
                 position: (526, 7),
                },
               ],
              },
              to: Variable {
               identifier: "false",
               position: (526, 17),
              },
             },
             Binding {
              from: AttributePath {
               parts: [
                Raw {
                 content: "description",
                 position: (527, 7),
                },
               ],
              },
              to: 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),
                },
               ],
               position: (527, 21),
              },
             },
            ],
            recursive: false,
            position: (524, 43),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (456, 13),
      },
     },
     Binding {
      from: AttributePath {
       parts: [
        Raw {
         content: "config",
         position: (539, 3),
        },
       ],
      },
      to: Map {
       bindings: [
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (541, 5),
           },
           Raw {
            content: "users",
            position: (541, 11),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "root",
               position: (542, 7),
              },
             ],
            },
            to: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "uid",
                  position: (543, 9),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "ids",
                 position: (543, 15),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "uids",
                   position: (543, 19),
                  },
                  Raw {
                   content: "root",
                   position: (543, 24),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (544, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "System administrator",
                  position: (544, 24),
                 },
                ],
                position: (544, 23),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "home",
                  position: (545, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "/root",
                  position: (545, 17),
                 },
                ],
                position: (545, 16),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "shell",
                  position: (546, 9),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (546, 17),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "cfg",
                   position: (546, 27),
                  },
                  attribute_path: AttributePath {
                   parts: [
                    Raw {
                     content: "defaultUserShell",
                     position: (546, 31),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "group",
                  position: (547, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "root",
                  position: (547, 18),
                 },
                ],
                position: (547, 17),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "initialHashedPassword",
                  position: (548, 9),
                 },
                ],
               },
               to: FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (548, 33),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "!",
                    position: (548, 44),
                   },
                  ],
                  position: (548, 43),
                 },
                ],
               },
              },
             ],
             recursive: false,
             position: (542, 14),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "nobody",
               position: (550, 7),
              },
             ],
            },
            to: Map {
             bindings: [
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "uid",
                  position: (551, 9),
                 },
                ],
               },
               to: PropertyAccess {
                expression: Variable {
                 identifier: "ids",
                 position: (551, 15),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "uids",
                   position: (551, 19),
                  },
                  Raw {
                   content: "nobody",
                   position: (551, 24),
                  },
                 ],
                },
                default: None,
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "isSystemUser",
                  position: (552, 9),
                 },
                ],
               },
               to: Variable {
                identifier: "true",
                position: (552, 24),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "description",
                  position: (553, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "Unprivileged account (don't use!)",
                  position: (553, 24),
                 },
                ],
                position: (553, 23),
               },
              },
              Binding {
               from: AttributePath {
                parts: [
                 Raw {
                  content: "group",
                  position: (554, 9),
                 },
                ],
               },
               to: String {
                parts: [
                 Raw {
                  content: "nogroup",
                  position: (554, 18),
                 },
                ],
                position: (554, 17),
               },
              },
             ],
             recursive: false,
             position: (550, 16),
            },
           },
          ],
          recursive: false,
          position: (541, 19),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "users",
            position: (558, 5),
           },
           Raw {
            content: "groups",
            position: (558, 11),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "root",
               position: (559, 7),
              },
              Raw {
               content: "gid",
               position: (559, 12),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (559, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (559, 22),
               },
               Raw {
                content: "root",
                position: (559, 27),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "wheel",
               position: (560, 7),
              },
              Raw {
               content: "gid",
               position: (560, 13),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (560, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (560, 23),
               },
               Raw {
                content: "wheel",
                position: (560, 28),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "disk",
               position: (561, 7),
              },
              Raw {
               content: "gid",
               position: (561, 12),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (561, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (561, 22),
               },
               Raw {
                content: "disk",
                position: (561, 27),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "kmem",
               position: (562, 7),
              },
              Raw {
               content: "gid",
               position: (562, 12),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (562, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (562, 22),
               },
               Raw {
                content: "kmem",
                position: (562, 27),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "tty",
               position: (563, 7),
              },
              Raw {
               content: "gid",
               position: (563, 11),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (563, 17),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (563, 21),
               },
               Raw {
                content: "tty",
                position: (563, 26),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "floppy",
               position: (564, 7),
              },
              Raw {
               content: "gid",
               position: (564, 14),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (564, 20),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (564, 24),
               },
               Raw {
                content: "floppy",
                position: (564, 29),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "uucp",
               position: (565, 7),
              },
              Raw {
               content: "gid",
               position: (565, 12),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (565, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (565, 22),
               },
               Raw {
                content: "uucp",
                position: (565, 27),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "lp",
               position: (566, 7),
              },
              Raw {
               content: "gid",
               position: (566, 10),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (566, 16),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (566, 20),
               },
               Raw {
                content: "lp",
                position: (566, 25),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "cdrom",
               position: (567, 7),
              },
              Raw {
               content: "gid",
               position: (567, 13),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (567, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (567, 23),
               },
               Raw {
                content: "cdrom",
                position: (567, 28),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "tape",
               position: (568, 7),
              },
              Raw {
               content: "gid",
               position: (568, 12),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (568, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (568, 22),
               },
               Raw {
                content: "tape",
                position: (568, 27),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "audio",
               position: (569, 7),
              },
              Raw {
               content: "gid",
               position: (569, 13),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (569, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (569, 23),
               },
               Raw {
                content: "audio",
                position: (569, 28),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "video",
               position: (570, 7),
              },
              Raw {
               content: "gid",
               position: (570, 13),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (570, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (570, 23),
               },
               Raw {
                content: "video",
                position: (570, 28),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "dialout",
               position: (571, 7),
              },
              Raw {
               content: "gid",
               position: (571, 15),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (571, 21),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (571, 25),
               },
               Raw {
                content: "dialout",
                position: (571, 30),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "nogroup",
               position: (572, 7),
              },
              Raw {
               content: "gid",
               position: (572, 15),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (572, 21),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (572, 25),
               },
               Raw {
                content: "nogroup",
                position: (572, 30),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "users",
               position: (573, 7),
              },
              Raw {
               content: "gid",
               position: (573, 13),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (573, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (573, 23),
               },
               Raw {
                content: "users",
                position: (573, 28),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "nixbld",
               position: (574, 7),
              },
              Raw {
               content: "gid",
               position: (574, 14),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (574, 20),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (574, 24),
               },
               Raw {
                content: "nixbld",
                position: (574, 29),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "utmp",
               position: (575, 7),
              },
              Raw {
               content: "gid",
               position: (575, 12),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (575, 18),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (575, 22),
               },
               Raw {
                content: "utmp",
                position: (575, 27),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "adm",
               position: (576, 7),
              },
              Raw {
               content: "gid",
               position: (576, 11),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (576, 17),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (576, 21),
               },
               Raw {
                content: "adm",
                position: (576, 26),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "input",
               position: (577, 7),
              },
              Raw {
               content: "gid",
               position: (577, 13),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (577, 19),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (577, 23),
               },
               Raw {
                content: "input",
                position: (577, 28),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "kvm",
               position: (578, 7),
              },
              Raw {
               content: "gid",
               position: (578, 11),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (578, 17),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (578, 21),
               },
               Raw {
                content: "kvm",
                position: (578, 26),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "render",
               position: (579, 7),
              },
              Raw {
               content: "gid",
               position: (579, 14),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (579, 20),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (579, 24),
               },
               Raw {
                content: "render",
                position: (579, 29),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "sgx",
               position: (580, 7),
              },
              Raw {
               content: "gid",
               position: (580, 11),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (580, 17),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (580, 21),
               },
               Raw {
                content: "sgx",
                position: (580, 26),
               },
              ],
             },
             default: None,
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "shadow",
               position: (581, 7),
              },
              Raw {
               content: "gid",
               position: (581, 14),
              },
             ],
            },
            to: PropertyAccess {
             expression: Variable {
              identifier: "ids",
              position: (581, 20),
             },
             attribute_path: AttributePath {
              parts: [
               Raw {
                content: "gids",
                position: (581, 24),
               },
               Raw {
                content: "shadow",
                position: (581, 29),
               },
              ],
             },
             default: None,
            },
           },
          ],
          recursive: false,
          position: (558, 20),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (584, 5),
           },
           Raw {
            content: "activationScripts",
            position: (584, 12),
           },
           Raw {
            content: "users",
            position: (584, 30),
           },
          ],
         },
         to: Map {
          bindings: [
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "supportsDryActivation",
               position: (585, 7),
              },
             ],
            },
            to: Variable {
             identifier: "true",
             position: (585, 31),
            },
           },
           Binding {
            from: AttributePath {
             parts: [
              Raw {
               content: "text",
               position: (586, 7),
              },
             ],
            },
            to: String {
             parts: [
              Raw {
               content: "install -m 0700 -d /root\ninstall -m 0755 -d /home\n\n",
               position: (587, 1),
              },
              Interpolation {
               expression: FunctionApplication {
                function: PropertyAccess {
                 expression: Variable {
                  identifier: "pkgs",
                  position: (590, 11),
                 },
                 attribute_path: AttributePath {
                  parts: [
                   Raw {
                    content: "perl",
                    position: (590, 16),
                   },
                   Raw {
                    content: "withPackages",
                    position: (590, 21),
                   },
                  ],
                 },
                 default: None,
                },
                arguments: [
                 Parentheses {
                  expression: Function {
                   argument: Simple {
                    identifier: "p",
                   },
                   definition: List {
                    elements: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "p",
                       position: (590, 40),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "FileSlurp",
                         position: (590, 42),
                        },
                       ],
                      },
                      default: None,
                     },
                     PropertyAccess {
                      expression: Variable {
                       identifier: "p",
                       position: (590, 52),
                      },
                      attribute_path: AttributePath {
                       parts: [
                        Raw {
                         content: "JSON",
                         position: (590, 54),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                    position: (590, 38),
                   },
                   position: (590, 35),
                  },
                  position: (590, 34),
                 },
                ],
               },
              },
              Raw {
               content: "/bin/perl \\\n-w ",
               position: (590, 62),
              },
              Interpolation {
               expression: Path {
                parts: [
                 Raw {
                  content: "./update-users-groups.pl",
                  position: (591, 14),
                 },
                ],
                position: (591, 14),
               },
              },
              Raw {
               content: " ",
               position: (591, 39),
              },
              Interpolation {
               expression: Variable {
                identifier: "spec",
                position: (591, 42),
               },
              },
              Raw {
               content: "\n",
               position: (591, 47),
              },
             ],
             position: (586, 14),
            },
           },
          ],
          recursive: false,
          position: (584, 38),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "system",
            position: (596, 5),
           },
           Raw {
            content: "activationScripts",
            position: (596, 12),
           },
           Raw {
            content: "groups",
            position: (596, 30),
           },
          ],
         },
         to: FunctionApplication {
          function: Variable {
           identifier: "stringAfter",
           position: (596, 39),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "users",
                position: (596, 54),
               },
              ],
              position: (596, 53),
             },
            ],
            position: (596, 51),
           },
           String {
            parts: [],
            position: (596, 63),
           },
          ],
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "environment",
            position: (599, 5),
           },
           Raw {
            content: "systemPackages",
            position: (599, 17),
           },
          ],
         },
         to: Variable {
          identifier: "systemShells",
          position: (599, 34),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "environment",
            position: (601, 5),
           },
           Raw {
            content: "etc",
            position: (601, 17),
           },
          ],
         },
         to: Parentheses {
          expression: FunctionApplication {
           function: Variable {
            identifier: "mapAttrs'",
            position: (601, 24),
           },
           arguments: [
            Parentheses {
             expression: Function {
              argument: Simple {
               identifier: "_",
              },
              definition: Function {
               argument: Destructured {
                identifier: None,
                arguments: [
                 DestructuredArgument {
                  identifier: "packages",
                  default: None,
                 },
                 DestructuredArgument {
                  identifier: "name",
                  default: None,
                 },
                ],
                ellipsis: true,
               },
               definition: Map {
                bindings: [
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "name",
                     position: (602, 7),
                    },
                   ],
                  },
                  to: String {
                   parts: [
                    Raw {
                     content: "profiles/per-user/",
                     position: (602, 15),
                    },
                    Interpolation {
                     expression: Variable {
                      identifier: "name",
                      position: (602, 35),
                     },
                    },
                   ],
                   position: (602, 14),
                  },
                 },
                 Binding {
                  from: AttributePath {
                   parts: [
                    Raw {
                     content: "value",
                     position: (603, 7),
                    },
                    Raw {
                     content: "source",
                     position: (603, 13),
                    },
                   ],
                  },
                  to: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (603, 22),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "buildEnv",
                       position: (603, 27),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    Map {
                     bindings: [
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "name",
                          position: (604, 9),
                         },
                        ],
                       },
                       to: String {
                        parts: [
                         Raw {
                          content: "user-environment",
                          position: (604, 17),
                         },
                        ],
                        position: (604, 16),
                       },
                      },
                      Binding {
                       from: AttributePath {
                        parts: [
                         Raw {
                          content: "paths",
                          position: (605, 9),
                         },
                        ],
                       },
                       to: Variable {
                        identifier: "packages",
                        position: (605, 17),
                       },
                      },
                      Inherit {
                       from: Some(
                        PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (606, 18),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "environment",
                            position: (606, 25),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       attributes: [
                        Raw {
                         content: "pathsToLink",
                         position: (606, 38),
                        },
                        Raw {
                         content: "extraOutputsToInstall",
                         position: (606, 50),
                        },
                       ],
                      },
                      Inherit {
                       from: Some(
                        PropertyAccess {
                         expression: Variable {
                          identifier: "config",
                          position: (607, 18),
                         },
                         attribute_path: AttributePath {
                          parts: [
                           Raw {
                            content: "system",
                            position: (607, 25),
                           },
                           Raw {
                            content: "path",
                            position: (607, 32),
                           },
                          ],
                         },
                         default: None,
                        },
                       ),
                       attributes: [
                        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),
             },
             position: (601, 34),
            },
            Parentheses {
             expression: FunctionApplication {
              function: Variable {
               identifier: "filterAttrs",
               position: (609, 9),
              },
              arguments: [
               Parentheses {
                expression: Function {
                 argument: Simple {
                  identifier: "_",
                 },
                 definition: Function {
                  argument: Simple {
                   identifier: "u",
                  },
                  definition: BinaryOperation {
                   operator: NotEqualTo,
                   operands: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "u",
                      position: (609, 28),
                     },
                     attribute_path: AttributePath {
                      parts: [
                       Raw {
                        content: "packages",
                        position: (609, 30),
                       },
                      ],
                     },
                     default: None,
                    },
                    List {
                     elements: [],
                     position: (609, 42),
                    },
                   ],
                   position: (609, 39),
                  },
                  position: (609, 25),
                 },
                 position: (609, 22),
                },
                position: (609, 21),
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "cfg",
                 position: (609, 46),
                },
                attribute_path: AttributePath {
                 parts: [
                  Raw {
                   content: "users",
                   position: (609, 50),
                  },
                 ],
                },
                default: None,
               },
              ],
             },
             position: (609, 8),
            },
           ],
          },
          position: (601, 23),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "environment",
            position: (611, 5),
           },
           Raw {
            content: "profiles",
            position: (611, 17),
           },
          ],
         },
         to: List {
          elements: [
           String {
            parts: [
             Raw {
              content: "$HOME/.nix-profile",
              position: (612, 8),
             },
            ],
            position: (612, 7),
           },
           String {
            parts: [
             Raw {
              content: "/etc/profiles/per-user/$USER",
              position: (613, 8),
             },
            ],
            position: (613, 7),
           },
          ],
          position: (611, 28),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "assertions",
            position: (616, 5),
           },
          ],
         },
         to: BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "assertion",
                   position: (617, 9),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: LogicalOr,
                 operands: [
                  UnaryOperation {
                   operator: Not,
                   operand: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (617, 22),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      Raw {
                       content: "enforceIdUniqueness",
                       position: (617, 26),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (617, 21),
                  },
                  Parentheses {
                   expression: BinaryOperation {
                    operator: LogicalAnd,
                    operands: [
                     Variable {
                      identifier: "uidsAreUnique",
                      position: (617, 50),
                     },
                     Variable {
                      identifier: "gidsAreUnique",
                      position: (617, 67),
                     },
                    ],
                    position: (617, 64),
                   },
                   position: (617, 49),
                  },
                 ],
                 position: (617, 46),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "message",
                   position: (618, 9),
                  },
                 ],
                },
                to: String {
                 parts: [
                  Raw {
                   content: "UIDs and GIDs must be unique!",
                   position: (618, 20),
                  },
                 ],
                 position: (618, 19),
                },
               },
              ],
              recursive: false,
              position: (617, 7),
             },
             Map {
              bindings: [
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "assertion",
                   position: (627, 9),
                  },
                 ],
                },
                to: BinaryOperation {
                 operator: Implication,
                 operands: [
                  UnaryOperation {
                   operator: Not,
                   operand: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (627, 22),
                    },
                    attribute_path: AttributePath {
                     parts: [
                      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 {
                       parts: [
                        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),
                      },
                      Parentheses {
                       expression: BinaryOperation {
                        operator: Concatenation,
                        operands: [
                         FunctionApplication {
                          function: Variable {
                           identifier: "mapAttrsToList",
                           position: (628, 19),
                          },
                          arguments: [
                           Parentheses {
                            expression: Function {
                             argument: Simple {
                              identifier: "name",
                             },
                             definition: Function {
                              argument: Simple {
                               identifier: "cfg",
                              },
                              definition: BinaryOperation {
                               operator: LogicalAnd,
                               operands: [
                                Parentheses {
                                 expression: 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, 22),
                                       },
                                      ],
                                      position: (629, 19),
                                     },
                                     BinaryOperation {
                                      operator: EqualTo,
                                      operands: [
                                       PropertyAccess {
                                        expression: Variable {
                                         identifier: "cfg",
                                         position: (630, 17),
                                        },
                                        attribute_path: AttributePath {
                                         parts: [
                                          Raw {
                                           content: "group",
                                           position: (630, 21),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                       String {
                                        parts: [
                                         Raw {
                                          content: "wheel",
                                          position: (630, 31),
                                         },
                                        ],
                                        position: (630, 30),
                                       },
                                      ],
                                      position: (630, 27),
                                     },
                                    ],
                                    position: (630, 14),
                                   },
                                   FunctionApplication {
                                    function: Variable {
                                     identifier: "elem",
                                     position: (631, 17),
                                    },
                                    arguments: [
                                     String {
                                      parts: [
                                       Raw {
                                        content: "wheel",
                                        position: (631, 23),
                                       },
                                      ],
                                      position: (631, 22),
                                     },
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "cfg",
                                       position: (631, 30),
                                      },
                                      attribute_path: AttributePath {
                                       parts: [
                                        Raw {
                                         content: "extraGroups",
                                         position: (631, 34),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    ],
                                   },
                                  ],
                                  position: (631, 14),
                                 },
                                 position: (629, 13),
                                },
                                Parentheses {
                                 expression: 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 {
                                             parts: [
                                              Raw {
                                               content: "hashedPassword",
                                               position: (633, 30),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                          ],
                                         },
                                         BinaryOperation {
                                          operator: NotEqualTo,
                                          operands: [
                                           PropertyAccess {
                                            expression: Variable {
                                             identifier: "cfg",
                                             position: (634, 17),
                                            },
                                            attribute_path: AttributePath {
                                             parts: [
                                              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 {
                                           parts: [
                                            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 {
                                         parts: [
                                          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 {
                                       parts: [
                                        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: (633, 13),
                                },
                               ],
                               position: (632, 13),
                              },
                              position: (628, 41),
                             },
                             position: (628, 35),
                            },
                            position: (628, 34),
                           },
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (638, 13),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "users",
                               position: (638, 17),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                         List {
                          elements: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "config",
                             position: (639, 13),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              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: (628, 18),
                      },
                     ],
                    },
                   ],
                   position: (627, 68),
                  },
                 ],
                 position: (627, 39),
                },
               },
               Binding {
                from: AttributePath {
                 parts: [
                  Raw {
                   content: "message",
                   position: (641, 9),
                  },
                 ],
                },
                to: 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),
                  },
                 ],
                 position: (641, 19),
                },
               },
              ],
              recursive: false,
              position: (620, 7),
             },
            ],
            position: (616, 18),
           },
           FunctionApplication {
            function: Variable {
             identifier: "flatten",
             position: (649, 10),
            },
            arguments: [
             Parentheses {
              expression: 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 {
                  parts: [
                   Raw {
                    content: "users",
                    position: (649, 43),
                   },
                  ],
                 },
                 default: None,
                },
                Parentheses {
                 expression: Function {
                  argument: Simple {
                   identifier: "name",
                  },
                  definition: Function {
                   argument: Simple {
                    identifier: "user",
                   },
                   definition: List {
                    elements: [
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "assertion",
                           position: (652, 9),
                          },
                         ],
                        },
                        to: BinaryOperation {
                         operator: Implication,
                         operands: [
                          Parentheses {
                           expression: BinaryOperation {
                            operator: NotEqualTo,
                            operands: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "user",
                               position: (652, 22),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "hashedPassword",
                                 position: (652, 27),
                                },
                               ],
                              },
                              default: None,
                             },
                             Variable {
                              identifier: "null",
                              position: (652, 45),
                             },
                            ],
                            position: (652, 42),
                           },
                           position: (652, 21),
                          },
                          Parentheses {
                           expression: BinaryOperation {
                            operator: EqualTo,
                            operands: [
                             FunctionApplication {
                              function: PropertyAccess {
                               expression: Variable {
                                identifier: "builtins",
                                position: (653, 13),
                               },
                               attribute_path: AttributePath {
                                parts: [
                                 Raw {
                                  content: "match",
                                  position: (653, 22),
                                 },
                                ],
                               },
                               default: None,
                              },
                              arguments: [
                               String {
                                parts: [
                                 Raw {
                                  content: ".*:.*",
                                  position: (653, 29),
                                 },
                                ],
                                position: (653, 28),
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "user",
                                 position: (653, 36),
                                },
                                attribute_path: AttributePath {
                                 parts: [
                                  Raw {
                                   content: "hashedPassword",
                                   position: (653, 41),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ],
                             },
                             Variable {
                              identifier: "null",
                              position: (653, 59),
                             },
                            ],
                            position: (653, 56),
                           },
                           position: (653, 12),
                          },
                         ],
                         position: (653, 9),
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "message",
                           position: (654, 9),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "            The password hash of user \"",
                           position: (655, 1),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (655, 42),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              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),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (658, 62),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (658, 67),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "\".hashedPassword`.",
                           position: (658, 72),
                          },
                         ],
                         position: (654, 19),
                        },
                       },
                      ],
                      recursive: false,
                      position: (651, 9),
                     },
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "assertion",
                           position: (661, 13),
                          },
                         ],
                        },
                        to: LetIn {
                         bindings: [
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "xor",
                              position: (662, 15),
                             },
                            ],
                           },
                           to: Function {
                            argument: Simple {
                             identifier: "a",
                            },
                            definition: Function {
                             argument: Simple {
                              identifier: "b",
                             },
                             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),
                           },
                          },
                          Binding {
                           from: AttributePath {
                            parts: [
                             Raw {
                              content: "isEffectivelySystemUser",
                              position: (663, 15),
                             },
                            ],
                           },
                           to: BinaryOperation {
                            operator: LogicalOr,
                            operands: [
                             PropertyAccess {
                              expression: Variable {
                               identifier: "user",
                               position: (663, 41),
                              },
                              attribute_path: AttributePath {
                               parts: [
                                Raw {
                                 content: "isSystemUser",
                                 position: (663, 46),
                                },
                               ],
                              },
                              default: None,
                             },
                             Parentheses {
                              expression: BinaryOperation {
                               operator: LogicalAnd,
                               operands: [
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "user",
                                    position: (663, 63),
                                   },
                                   attribute_path: AttributePath {
                                    parts: [
                                     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 {
                                    parts: [
                                     Raw {
                                      content: "uid",
                                      position: (663, 88),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Int {
                                   value: 500,
                                   position: (663, 94),
                                  },
                                 ],
                                 position: (663, 92),
                                },
                               ],
                               position: (663, 80),
                              },
                              position: (663, 62),
                             },
                            ],
                            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 {
                             parts: [
                              Raw {
                               content: "isNormalUser",
                               position: (664, 49),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                         },
                         position: (661, 25),
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "message",
                           position: (665, 13),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "Exactly one of users.users.",
                           position: (666, 1),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (666, 44),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (666, 49),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: ".isSystemUser and users.users.",
                           position: (666, 54),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (666, 86),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (666, 91),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: ".isNormalUser must be set.\n",
                           position: (666, 96),
                          },
                         ],
                         position: (665, 23),
                        },
                       },
                      ],
                      recursive: false,
                      position: (660, 11),
                     },
                     Map {
                      bindings: [
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "assertion",
                           position: (670, 13),
                          },
                         ],
                        },
                        to: BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "user",
                            position: (670, 25),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "group",
                              position: (670, 30),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [],
                           position: (670, 39),
                          },
                         ],
                         position: (670, 36),
                        },
                       },
                       Binding {
                        from: AttributePath {
                         parts: [
                          Raw {
                           content: "message",
                           position: (671, 13),
                          },
                         ],
                        },
                        to: String {
                         parts: [
                          Raw {
                           content: "users.users.",
                           position: (672, 1),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (672, 29),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              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),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (675, 29),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (675, 34),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: ".group = \"",
                           position: (675, 39),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (675, 51),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (675, 56),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "\";\nusers.groups.",
                           position: (675, 61),
                          },
                          Interpolation {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "user",
                             position: (676, 30),
                            },
                            attribute_path: AttributePath {
                             parts: [
                              Raw {
                               content: "name",
                               position: (676, 35),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: " = {};\n",
                           position: (676, 40),
                          },
                         ],
                         position: (671, 23),
                        },
                       },
                      ],
                      recursive: false,
                      position: (669, 11),
                     },
                    ],
                    position: (650, 7),
                   },
                   position: (649, 56),
                  },
                  position: (649, 50),
                 },
                 position: (649, 49),
                },
               ],
              },
              position: (649, 18),
             },
            ],
           },
          ],
          position: (649, 7),
         },
        },
        Binding {
         from: AttributePath {
          parts: [
           Raw {
            content: "warnings",
            position: (682, 5),
           },
          ],
         },
         to: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "builtins",
            position: (683, 7),
           },
           attribute_path: AttributePath {
            parts: [
             Raw {
              content: "filter",
              position: (683, 16),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Parentheses {
            expression: Function {
             argument: Simple {
              identifier: "x",
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "x",
                position: (683, 27),
               },
               Variable {
                identifier: "null",
                position: (683, 32),
               },
              ],
              position: (683, 29),
             },
             position: (683, 24),
            },
            position: (683, 23),
           },
           Parentheses {
            expression: 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 {
                parts: [
                 Raw {
                  content: "users",
                  position: (684, 33),
                 },
                ],
               },
               default: None,
              },
              Parentheses {
               expression: Function {
                argument: Simple {
                 identifier: "_",
                },
                definition: Function {
                 argument: Simple {
                  identifier: "user",
                 },
                 definition: LetIn {
                  bindings: [
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "sep",
                       position: (694, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "\\$",
                       position: (694, 18),
                      },
                     ],
                     position: (694, 17),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "base64",
                       position: (695, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "[a-zA-Z0-9./]+",
                       position: (695, 21),
                      },
                     ],
                     position: (695, 20),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "id",
                       position: (696, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "[a-z0-9-]+",
                       position: (696, 17),
                      },
                     ],
                     position: (696, 16),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "value",
                       position: (697, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "[a-zA-Z0-9/+.-]+",
                       position: (697, 20),
                      },
                     ],
                     position: (697, 19),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "options",
                       position: (698, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Interpolation {
                       expression: Variable {
                        identifier: "id",
                        position: (698, 24),
                       },
                      },
                      Raw {
                       content: "(=",
                       position: (698, 27),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "value",
                        position: (698, 31),
                       },
                      },
                      Raw {
                       content: ")?(,",
                       position: (698, 37),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "id",
                        position: (698, 43),
                       },
                      },
                      Raw {
                       content: "=",
                       position: (698, 46),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "value",
                        position: (698, 49),
                       },
                      },
                      Raw {
                       content: ")*",
                       position: (698, 55),
                      },
                     ],
                     position: (698, 21),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "scheme",
                       position: (699, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Interpolation {
                       expression: Variable {
                        identifier: "id",
                        position: (699, 24),
                       },
                      },
                      Raw {
                       content: "(",
                       position: (699, 27),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "sep",
                        position: (699, 30),
                       },
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "options",
                        position: (699, 36),
                       },
                      },
                      Raw {
                       content: ")?",
                       position: (699, 44),
                      },
                     ],
                     position: (699, 21),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "content",
                       position: (700, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Interpolation {
                       expression: Variable {
                        identifier: "base64",
                        position: (700, 24),
                       },
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "sep",
                        position: (700, 33),
                       },
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "base64",
                        position: (700, 39),
                       },
                      },
                     ],
                     position: (700, 21),
                    },
                   },
                   Binding {
                    from: AttributePath {
                     parts: [
                      Raw {
                       content: "mcf",
                       position: (701, 11),
                      },
                     ],
                    },
                    to: String {
                     parts: [
                      Raw {
                       content: "^",
                       position: (701, 18),
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "sep",
                        position: (701, 21),
                       },
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "scheme",
                        position: (701, 27),
                       },
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "sep",
                        position: (701, 36),
                       },
                      },
                      Interpolation {
                       expression: Variable {
                        identifier: "content",
                        position: (701, 42),
                       },
                      },
                      Raw {
                       content: "$",
                       position: (701, 50),
                      },
                     ],
                     position: (701, 17),
                    },
                   },
                  ],
                  target: IfThenElse {
                   predicate: Parentheses {
                    expression: 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 {
                            parts: [
                             Raw {
                              content: "hashedPassword",
                              position: (703, 30),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "user",
                            position: (704, 16),
                           },
                           attribute_path: AttributePath {
                            parts: [
                             Raw {
                              content: "hashedPassword",
                              position: (704, 21),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [],
                           position: (704, 39),
                          },
                         ],
                         position: (704, 36),
                        },
                       ],
                       position: (704, 13),
                      },
                      BinaryOperation {
                       operator: EqualTo,
                       operands: [
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "builtins",
                           position: (705, 16),
                          },
                          attribute_path: AttributePath {
                           parts: [
                            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 {
                            parts: [
                             Raw {
                              content: "hashedPassword",
                              position: (705, 40),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                        Variable {
                         identifier: "null",
                         position: (705, 58),
                        },
                       ],
                       position: (705, 55),
                      },
                     ],
                     position: (705, 13),
                    },
                    position: (703, 12),
                   },
                   then: String {
                    parts: [
                     Raw {
                      content: "          The password hash of user \"",
                      position: (707, 1),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "user",
                        position: (707, 40),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         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),
                     },
                     Interpolation {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "user",
                        position: (709, 53),
                       },
                       attribute_path: AttributePath {
                        parts: [
                         Raw {
                          content: "name",
                          position: (709, 58),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\".hashedPassword`.",
                      position: (709, 63),
                     },
                    ],
                    position: (706, 14),
                   },
                   else_: Variable {
                    identifier: "null",
                    position: (710, 14),
                   },
                   position: (703, 9),
                  },
                  position: (693, 9),
                 },
                 position: (684, 43),
                },
                position: (684, 40),
               },
               position: (684, 39),
              },
             ],
            },
            position: (683, 38),
           },
          ],
         },
        },
       ],
       recursive: false,
       position: (539, 12),
      },
     },
    ],
    recursive: false,
    position: (448, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}