---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (6, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "parentConfig",
        position: (9, 3),
       },
      ],
     },
     Variable {
      identifier: "config",
      position: (9, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pamOpts",
        position: (11, 3),
       },
      ],
     },
     Function {
      argument: None,
      arguments: FunctionArguments {
       arguments: [
        FunctionArgument {
         identifier: "name",
         default: None,
        },
        FunctionArgument {
         identifier: "config",
         default: None,
        },
       ],
       ellipsis: true,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "cfg",
            position: (11, 40),
           },
          ],
         },
         Variable {
          identifier: "config",
          position: (11, 46),
         },
        ),
       ],
       target: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "config",
             position: (11, 61),
            },
           ],
          },
          Variable {
           identifier: "parentConfig",
           position: (11, 70),
          },
         ),
        ],
        target: Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "options",
              position: (13, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "name",
                 position: (15, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (15, 14),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "example",
                      position: (16, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "sshd",
                      position: (16, 20),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (17, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (17, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (17, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (18, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Name of the PAM service.",
                      position: (18, 24),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (15, 23),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "unixAuth",
                 position: (21, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (21, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (22, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (22, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (23, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (23, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (23, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (24, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether users can log in with passwords defined in\n<filename>/etc/shadow</filename>.\n",
                      position: (25, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (21, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "rootOK",
                 position: (30, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (30, 16),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (31, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (31, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (32, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (32, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (32, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (33, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, root doesn't need to authenticate (e.g. for the\n<command>useradd</command> service).\n",
                      position: (34, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (30, 25),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "p11Auth",
                 position: (39, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (39, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (40, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (40, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (40, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (40, 35),
                      },
                      Raw {
                       content: "p11",
                       position: (40, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (40, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (41, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (41, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.p11.enable",
                        position: (41, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (42, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (42, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (42, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (43, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, keys listed in\n<filename>~/.ssh/authorized_keys</filename> and\n<filename>~/.eid/authorized_certificates</filename>\ncan be used to log in with the associated PKCS#11 tokens.\n",
                      position: (44, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (39, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "u2fAuth",
                 position: (51, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (51, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (52, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (52, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (52, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (52, 35),
                      },
                      Raw {
                       content: "u2f",
                       position: (52, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (52, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (53, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (53, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.u2f.enable",
                        position: (53, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (54, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (54, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (54, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (55, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, users listed in\n<filename>$XDG_CONFIG_HOME/Yubico/u2f_keys</filename> (or\n<filename>$HOME/.config/Yubico/u2f_keys</filename> if XDG variable is\nnot set) are able to log in with the associated U2F key. Path can be\nchanged using <option>security.pam.u2f.authFile</option> option.\n",
                      position: (56, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (51, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "yubicoAuth",
                 position: (64, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (64, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (65, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (65, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (65, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (65, 35),
                      },
                      Raw {
                       content: "yubico",
                       position: (65, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (65, 46),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (66, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (66, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.yubico.enable",
                        position: (66, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (67, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (67, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (67, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (68, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, users listed in\n<filename>~/.yubico/authorized_yubikeys</filename>\nare able to log in with the associated Yubikey tokens.\n",
                      position: (69, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (64, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "googleAuthenticator",
                 position: (75, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (76, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (76, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (77, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (77, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (78, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (78, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (78, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (79, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "If set, users with enabled Google Authenticator (created\n<filename>~/.google_authenticator</filename>) will be required\nto provide Google Authenticator token to log in.\n",
                         position: (80, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (76, 27),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (75, 29),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "usbAuth",
                 position: (87, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (87, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (88, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (88, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (88, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (88, 35),
                      },
                      Raw {
                       content: "usb",
                       position: (88, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (88, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (89, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (89, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.usb.enable",
                        position: (89, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (90, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (90, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (90, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (91, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, users listed in\n<filename>/etc/pamusb.conf</filename> are able to log in\nwith the associated USB key.\n",
                      position: (92, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (87, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "otpwAuth",
                 position: (98, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (98, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (99, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (99, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (99, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (99, 35),
                      },
                      Raw {
                       content: "enableOTPW",
                       position: (99, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (100, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (100, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.enableOTPW",
                        position: (100, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (101, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (101, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (101, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (102, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, the OTPW system will be used (if\n<filename>~/.otpw</filename> exists).\n",
                      position: (103, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (98, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "googleOsLoginAccountVerification",
                 position: (108, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (108, 42),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (109, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (109, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (110, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (110, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (110, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (111, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, will use the Google OS Login PAM modules\n(<literal>pam_oslogin_login</literal>,\n<literal>pam_oslogin_admin</literal>) to verify possible OS Login\nusers and set sudoers configuration accordingly.\nThis only makes sense to enable for the <literal>sshd</literal> PAM\nservice.\n",
                      position: (112, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (108, 51),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "googleOsLoginAuthentication",
                 position: (121, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (121, 37),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (122, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (122, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (123, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (123, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (123, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (124, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, will use the <literal>pam_oslogin_login</literal>'s user\nauthentication methods to authenticate users using 2FA.\nThis only makes sense to enable for the <literal>sshd</literal> PAM\nservice.\n",
                      position: (125, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (121, 46),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "fprintAuth",
                 position: (132, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (132, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (133, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (133, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "services",
                       position: (133, 26),
                      },
                      Raw {
                       content: "fprintd",
                       position: (133, 35),
                      },
                      Raw {
                       content: "enable",
                       position: (133, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (134, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (134, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.services.fprintd.enable",
                        position: (134, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (135, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (135, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (135, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (136, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, fingerprint reader will be used (if exists and\nyour fingerprints are enrolled).\n",
                      position: (137, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (132, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "oathAuth",
                 position: (142, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (142, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (143, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (143, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (143, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (143, 35),
                      },
                      Raw {
                       content: "oath",
                       position: (143, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (143, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (144, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (144, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.oath.enable",
                        position: (144, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (145, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (145, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (145, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (146, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, the OATH Toolkit will be used.\n",
                      position: (147, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (142, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "sshAgentAuth",
                 position: (151, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (151, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (152, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (152, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (153, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (153, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (153, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (154, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, the calling user's SSH agent is used to authenticate\nagainst the keys in the calling user's\n<filename>~/.ssh/authorized_keys</filename>.  This is useful\nfor <command>sudo</command> on password-less remote systems.\n",
                      position: (155, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (151, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "duoSecurity",
                 position: (162, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (163, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (163, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (164, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (164, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (165, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (165, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (165, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (166, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "If set, use the Duo Security pam module\n<literal>pam_duo</literal> for authentication.  Requires\nconfiguration of <option>security.duosec</option> options.\n",
                         position: (167, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (163, 27),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (162, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "startSession",
                 position: (174, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (174, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (175, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (175, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (176, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (176, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (176, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (177, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, the service will register a new session with\nsystemd's login manager.  For local sessions, this will give\nthe user access to audio devices, CD-ROM drives.  In the\ndefault PolicyKit configuration, it also allows the user to\nreboot the system.\n",
                      position: (178, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (174, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "setEnvironment",
                 position: (186, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (186, 24),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (187, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (187, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (187, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (188, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (188, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (189, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether the service should set the environment variables\nlisted in <option>environment.sessionVariables</option>\nusing <literal>pam_env.so</literal>.\n",
                      position: (190, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (186, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "setLoginUid",
                 position: (196, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (196, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (197, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (197, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (197, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (198, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Set the login uid of the process\n(<filename>/proc/self/loginuid</filename>) for auditing\npurposes.  The login uid is only set by ‘entry points’ like\n<command>login</command> and <command>sshd</command>, not by\ncommands like <command>sudo</command>.\n",
                      position: (199, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (196, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "ttyAudit",
                 position: (207, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (208, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (208, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (209, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (209, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (209, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (210, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (210, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (211, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Enable or disable TTY auditing for specified users\n",
                         position: (212, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (208, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enablePattern",
                    position: (216, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (216, 25),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (217, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (217, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "nullOr",
                           position: (217, 24),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (217, 31),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "str",
                            position: (217, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (218, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "null",
                       position: (218, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (219, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "For each user matching one of comma-separated\nglob patterns, enable TTY auditing\n",
                         position: (220, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (216, 34),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "disablePattern",
                    position: (225, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (225, 26),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (226, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (226, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "nullOr",
                           position: (226, 24),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (226, 31),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "str",
                            position: (226, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (227, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "null",
                       position: (227, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (228, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "For each user matching one of comma-separated\nglob patterns, disable TTY auditing\n",
                         position: (229, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (225, 35),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "openOnly",
                    position: (234, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (234, 20),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (235, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (235, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (235, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (236, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (236, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (237, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Set the TTY audit flag when opening the session,\nbut do not restore it when closing the session.\nUsing this option is necessary for some services\nthat don't fork() to run the authenticated session,\nsuch as sudo.\n",
                         position: (238, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (234, 29),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (207, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "forwardXAuth",
                 position: (247, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (247, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (248, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (248, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (249, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (249, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (249, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (250, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether X authentication keys should be passed from the\ncalling user to the target user (e.g. for\n<command>su</command>)\n",
                      position: (251, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (247, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "pamMount",
                 position: (257, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (257, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (258, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (258, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (258, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (258, 35),
                      },
                      Raw {
                       content: "mount",
                       position: (258, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (258, 45),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (259, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (259, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.mount.enable",
                        position: (259, 42),
                       },
                      ],
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (260, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (260, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (260, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (261, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Enable PAM mount (pam_mount) system to mount fileystems on user login.\n",
                      position: (262, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (257, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "allowNullPassword",
                 position: (266, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (266, 27),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (267, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (267, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (268, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (268, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (268, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (269, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to allow logging into accounts that have no password\nset (i.e., have an empty password field in\n<filename>/etc/passwd</filename> or\n<filename>/etc/group</filename>).  This does not enable\nlogging into disabled accounts (i.e., that have the password\nfield set to <literal>!</literal>).  Note that regardless of\nwhat the pam_unix documentation says, accounts with hashed\nempty passwords are always allowed to log in.\n",
                      position: (270, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (266, 36),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nodelay",
                 position: (281, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (281, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (282, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (282, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (283, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (283, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (283, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (284, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Wheather the delay after typing a wrong password should be disabled.\n",
                      position: (285, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (281, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "requireWheel",
                 position: (289, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (289, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (290, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (290, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (291, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (291, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (291, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (292, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to permit root access only to members of group wheel.\n",
                      position: (293, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (289, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "limits",
                 position: (297, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (297, 16),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (298, 9),
                     },
                    ],
                   },
                   List {
                    elements: [],
                    position: (298, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (299, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "limitsType",
                    position: (299, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (300, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Attribute set describing resource limits.  Defaults to the\nvalue of <option>security.pam.loginLimits</option>.\nThe meaning of the values is explained in <citerefentry>\n<refentrytitle>limits.conf</refentrytitle><manvolnum>5</manvolnum>\n</citerefentry>.\n",
                      position: (301, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (297, 25),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "showMotd",
                 position: (309, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (309, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (310, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (310, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (311, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (311, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (311, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (312, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to show the message of the day.",
                      position: (312, 24),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (309, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "makeHomeDir",
                 position: (315, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (315, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (316, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (316, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (317, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (317, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (317, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (318, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to try to create home directories for users\nwith <literal>$HOME</literal>s pointing to nonexistent\nlocations on session login.\n",
                      position: (319, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (315, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "updateWtmp",
                 position: (325, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (325, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (326, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (326, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (327, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (327, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (327, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (328, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to update <filename>/var/log/wtmp</filename>.",
                      position: (328, 24),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (325, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "logFailures",
                 position: (331, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (331, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (332, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (332, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (333, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (333, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (333, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (334, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to log authentication failures in <filename>/var/log/faillog</filename>.",
                      position: (334, 24),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (331, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enableAppArmor",
                 position: (337, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (337, 24),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (338, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (338, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (339, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (339, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (339, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (340, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Enable support for attaching AppArmor profiles at the\nuser/group level, e.g., as part of a role based access\ncontrol scheme.\n",
                      position: (341, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (337, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enableKwallet",
                 position: (347, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (347, 23),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (348, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (348, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (349, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (349, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (349, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (350, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If enabled, pam_wallet will attempt to automatically unlock the\nuser's default KDE wallet upon login. If the user has no wallet named\n\"kdewallet\", or the login password does not match their wallet\npassword, KDE will prompt separately after login.\n",
                      position: (351, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (347, 32),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "sssdStrictAccess",
                 position: (357, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (357, 26),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (358, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (358, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (359, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (359, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (359, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (360, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "enforce sssd access control",
                      position: (360, 24),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (357, 35),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enableGnomeKeyring",
                 position: (363, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (363, 28),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (364, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (364, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (365, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (365, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (365, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (366, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If enabled, pam_gnome_keyring will attempt to automatically unlock the\nuser's default Gnome keyring upon login. If the user login password does\nnot match their keyring password, Gnome Keyring will prompt separately\nafter login.\n",
                      position: (367, 1),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (363, 37),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "gnupg",
                 position: (374, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (375, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (375, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (376, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (376, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (376, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (377, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (377, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (378, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "If enabled, pam_gnupg will attempt to automatically unlock the\nuser's GPG keys with the login password via\n<command>gpg-agent</command>. The keygrips of all keys to be\nunlocked should be written to <filename>~/.pam-gnupg</filename>,\nand can be queried with <command>gpg -K --with-keygrip</command>.\nPresetting passphrases must be enabled by adding\n<literal>allow-preset-passphrase</literal> in\n<filename>~/.gnupg/gpg-agent.conf</filename>.\n",
                         position: (379, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (375, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "noAutostart",
                    position: (390, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (390, 23),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (391, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (391, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (391, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (392, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (392, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (393, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Don't start <command>gpg-agent</command> if it is not running.\nUseful in conjunction with starting <command>gpg-agent</command> as\na systemd user service.\n",
                         position: (394, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (390, 32),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "storeOnly",
                    position: (400, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (400, 21),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (401, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (401, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (401, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (402, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (402, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (403, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Don't send the password immediately after login, but store for PAM\n<literal>session</literal>.\n",
                         position: (404, 1),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (400, 30),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (374, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "text",
                 position: (410, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (410, 14),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (411, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (411, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "nullOr",
                        position: (411, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (411, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "lines",
                         position: (411, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (412, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Contents of the PAM service file.",
                      position: (412, 24),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (410, 23),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (13, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (420, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "name",
                 position: (421, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (421, 14),
               },
               arguments: [
                Variable {
                 identifier: "name",
                 position: (421, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "setLoginUid",
                 position: (422, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (422, 21),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (422, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "startSession",
                    position: (422, 35),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "limits",
                 position: (423, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (423, 16),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (423, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "security",
                    position: (423, 33),
                   },
                   Raw {
                    content: "pam",
                    position: (423, 42),
                   },
                   Raw {
                    content: "loginLimits",
                    position: (423, 46),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "text",
                 position: (428, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (428, 14),
               },
               arguments: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    BinaryOperation {
                     operator: Addition,
                     operands: [
                      BinaryOperation {
                       operator: Addition,
                       operands: [
                        BinaryOperation {
                         operator: Addition,
                         operands: [
                          BinaryOperation {
                           operator: Addition,
                           operands: [
                            BinaryOperation {
                             operator: Addition,
                             operands: [
                              BinaryOperation {
                               operator: Addition,
                               operands: [
                                BinaryOperation {
                                 operator: Addition,
                                 operands: [
                                  BinaryOperation {
                                   operator: Addition,
                                   operands: [
                                    BinaryOperation {
                                     operator: Addition,
                                     operands: [
                                      BinaryOperation {
                                       operator: Addition,
                                       operands: [
                                        BinaryOperation {
                                         operator: Addition,
                                         operands: [
                                          BinaryOperation {
                                           operator: Addition,
                                           operands: [
                                            BinaryOperation {
                                             operator: Addition,
                                             operands: [
                                              BinaryOperation {
                                               operator: Addition,
                                               operands: [
                                                BinaryOperation {
                                                 operator: Addition,
                                                 operands: [
                                                  BinaryOperation {
                                                   operator: Addition,
                                                   operands: [
                                                    BinaryOperation {
                                                     operator: Addition,
                                                     operands: [
                                                      BinaryOperation {
                                                       operator: Addition,
                                                       operands: [
                                                        BinaryOperation {
                                                         operator: Addition,
                                                         operands: [
                                                          BinaryOperation {
                                                           operator: Addition,
                                                           operands: [
                                                            BinaryOperation {
                                                             operator: Addition,
                                                             operands: [
                                                              BinaryOperation {
                                                               operator: Addition,
                                                               operands: [
                                                                BinaryOperation {
                                                                 operator: Addition,
                                                                 operands: [
                                                                  BinaryOperation {
                                                                   operator: Addition,
                                                                   operands: [
                                                                    BinaryOperation {
                                                                     operator: Addition,
                                                                     operands: [
                                                                      BinaryOperation {
                                                                       operator: Addition,
                                                                       operands: [
                                                                        BinaryOperation {
                                                                         operator: Addition,
                                                                         operands: [
                                                                          BinaryOperation {
                                                                           operator: Addition,
                                                                           operands: [
                                                                            BinaryOperation {
                                                                             operator: Addition,
                                                                             operands: [
                                                                              BinaryOperation {
                                                                               operator: Addition,
                                                                               operands: [
                                                                                BinaryOperation {
                                                                                 operator: Addition,
                                                                                 operands: [
                                                                                  BinaryOperation {
                                                                                   operator: Addition,
                                                                                   operands: [
                                                                                    BinaryOperation {
                                                                                     operator: Addition,
                                                                                     operands: [
                                                                                      BinaryOperation {
                                                                                       operator: Addition,
                                                                                       operands: [
                                                                                        BinaryOperation {
                                                                                         operator: Addition,
                                                                                         operands: [
                                                                                          BinaryOperation {
                                                                                           operator: Addition,
                                                                                           operands: [
                                                                                            BinaryOperation {
                                                                                             operator: Addition,
                                                                                             operands: [
                                                                                              BinaryOperation {
                                                                                               operator: Addition,
                                                                                               operands: [
                                                                                                BinaryOperation {
                                                                                                 operator: Addition,
                                                                                                 operands: [
                                                                                                  BinaryOperation {
                                                                                                   operator: Addition,
                                                                                                   operands: [
                                                                                                    BinaryOperation {
                                                                                                     operator: Addition,
                                                                                                     operands: [
                                                                                                      BinaryOperation {
                                                                                                       operator: Addition,
                                                                                                       operands: [
                                                                                                        BinaryOperation {
                                                                                                         operator: Addition,
                                                                                                         operands: [
                                                                                                          BinaryOperation {
                                                                                                           operator: Addition,
                                                                                                           operands: [
                                                                                                            BinaryOperation {
                                                                                                             operator: Addition,
                                                                                                             operands: [
                                                                                                              BinaryOperation {
                                                                                                               operator: Addition,
                                                                                                               operands: [
                                                                                                                BinaryOperation {
                                                                                                                 operator: Addition,
                                                                                                                 operands: [
                                                                                                                  BinaryOperation {
                                                                                                                   operator: Addition,
                                                                                                                   operands: [
                                                                                                                    BinaryOperation {
                                                                                                                     operator: Addition,
                                                                                                                     operands: [
                                                                                                                      BinaryOperation {
                                                                                                                       operator: Addition,
                                                                                                                       operands: [
                                                                                                                        String {
                                                                                                                         parts: [
                                                                                                                          Raw {
                                                                                                                           content: "# Account management.\naccount required pam_unix.so\n",
                                                                                                                           position: (431, 1),
                                                                                                                          },
                                                                                                                         ],
                                                                                                                        },
                                                                                                                        FunctionApplication {
                                                                                                                         function: Variable {
                                                                                                                          identifier: "optionalString",
                                                                                                                          position: (434, 11),
                                                                                                                         },
                                                                                                                         arguments: [
                                                                                                                          Variable {
                                                                                                                           identifier: "use_ldap",
                                                                                                                           position: (434, 26),
                                                                                                                          },
                                                                                                                          String {
                                                                                                                           parts: [
                                                                                                                            Raw {
                                                                                                                             content: "account sufficient ",
                                                                                                                             position: (435, 1),
                                                                                                                            },
                                                                                                                            Expression {
                                                                                                                             expression: Variable {
                                                                                                                              identifier: "pam_ldap",
                                                                                                                              position: (435, 34),
                                                                                                                             },
                                                                                                                            },
                                                                                                                            Raw {
                                                                                                                             content: "/lib/security/pam_ldap.so\n",
                                                                                                                             position: (435, 43),
                                                                                                                            },
                                                                                                                           ],
                                                                                                                          },
                                                                                                                         ],
                                                                                                                        },
                                                                                                                       ],
                                                                                                                       position: (433, 14),
                                                                                                                      },
                                                                                                                      FunctionApplication {
                                                                                                                       function: Variable {
                                                                                                                        identifier: "optionalString",
                                                                                                                        position: (437, 11),
                                                                                                                       },
                                                                                                                       arguments: [
                                                                                                                        BinaryOperation {
                                                                                                                         operator: LogicalAnd,
                                                                                                                         operands: [
                                                                                                                          PropertyAccess {
                                                                                                                           expression: Variable {
                                                                                                                            identifier: "config",
                                                                                                                            position: (437, 27),
                                                                                                                           },
                                                                                                                           attribute_path: AttributePath {
                                                                                                                            attributes: [
                                                                                                                             Raw {
                                                                                                                              content: "services",
                                                                                                                              position: (437, 34),
                                                                                                                             },
                                                                                                                             Raw {
                                                                                                                              content: "sssd",
                                                                                                                              position: (437, 43),
                                                                                                                             },
                                                                                                                             Raw {
                                                                                                                              content: "enable",
                                                                                                                              position: (437, 48),
                                                                                                                             },
                                                                                                                            ],
                                                                                                                           },
                                                                                                                           default: None,
                                                                                                                          },
                                                                                                                          BinaryOperation {
                                                                                                                           operator: EqualTo,
                                                                                                                           operands: [
                                                                                                                            PropertyAccess {
                                                                                                                             expression: Variable {
                                                                                                                              identifier: "cfg",
                                                                                                                              position: (437, 58),
                                                                                                                             },
                                                                                                                             attribute_path: AttributePath {
                                                                                                                              attributes: [
                                                                                                                               Raw {
                                                                                                                                content: "sssdStrictAccess",
                                                                                                                                position: (437, 62),
                                                                                                                               },
                                                                                                                              ],
                                                                                                                             },
                                                                                                                             default: None,
                                                                                                                            },
                                                                                                                            Variable {
                                                                                                                             identifier: "false",
                                                                                                                             position: (437, 80),
                                                                                                                            },
                                                                                                                           ],
                                                                                                                           position: (437, 78),
                                                                                                                          },
                                                                                                                         ],
                                                                                                                         position: (437, 55),
                                                                                                                        },
                                                                                                                        String {
                                                                                                                         parts: [
                                                                                                                          Raw {
                                                                                                                           content: "account sufficient ",
                                                                                                                           position: (438, 1),
                                                                                                                          },
                                                                                                                          Expression {
                                                                                                                           expression: PropertyAccess {
                                                                                                                            expression: Variable {
                                                                                                                             identifier: "pkgs",
                                                                                                                             position: (438, 34),
                                                                                                                            },
                                                                                                                            attribute_path: AttributePath {
                                                                                                                             attributes: [
                                                                                                                              Raw {
                                                                                                                               content: "sssd",
                                                                                                                               position: (438, 39),
                                                                                                                              },
                                                                                                                             ],
                                                                                                                            },
                                                                                                                            default: None,
                                                                                                                           },
                                                                                                                          },
                                                                                                                          Raw {
                                                                                                                           content: "/lib/security/pam_sss.so\n",
                                                                                                                           position: (438, 44),
                                                                                                                          },
                                                                                                                         ],
                                                                                                                        },
                                                                                                                       ],
                                                                                                                      },
                                                                                                                     ],
                                                                                                                     position: (436, 14),
                                                                                                                    },
                                                                                                                    FunctionApplication {
                                                                                                                     function: Variable {
                                                                                                                      identifier: "optionalString",
                                                                                                                      position: (440, 11),
                                                                                                                     },
                                                                                                                     arguments: [
                                                                                                                      BinaryOperation {
                                                                                                                       operator: LogicalAnd,
                                                                                                                       operands: [
                                                                                                                        PropertyAccess {
                                                                                                                         expression: Variable {
                                                                                                                          identifier: "config",
                                                                                                                          position: (440, 27),
                                                                                                                         },
                                                                                                                         attribute_path: AttributePath {
                                                                                                                          attributes: [
                                                                                                                           Raw {
                                                                                                                            content: "services",
                                                                                                                            position: (440, 34),
                                                                                                                           },
                                                                                                                           Raw {
                                                                                                                            content: "sssd",
                                                                                                                            position: (440, 43),
                                                                                                                           },
                                                                                                                           Raw {
                                                                                                                            content: "enable",
                                                                                                                            position: (440, 48),
                                                                                                                           },
                                                                                                                          ],
                                                                                                                         },
                                                                                                                         default: None,
                                                                                                                        },
                                                                                                                        PropertyAccess {
                                                                                                                         expression: Variable {
                                                                                                                          identifier: "cfg",
                                                                                                                          position: (440, 58),
                                                                                                                         },
                                                                                                                         attribute_path: AttributePath {
                                                                                                                          attributes: [
                                                                                                                           Raw {
                                                                                                                            content: "sssdStrictAccess",
                                                                                                                            position: (440, 62),
                                                                                                                           },
                                                                                                                          ],
                                                                                                                         },
                                                                                                                         default: None,
                                                                                                                        },
                                                                                                                       ],
                                                                                                                       position: (440, 55),
                                                                                                                      },
                                                                                                                      String {
                                                                                                                       parts: [
                                                                                                                        Raw {
                                                                                                                         content: "account [default=bad success=ok user_unknown=ignore] ",
                                                                                                                         position: (441, 1),
                                                                                                                        },
                                                                                                                        Expression {
                                                                                                                         expression: PropertyAccess {
                                                                                                                          expression: Variable {
                                                                                                                           identifier: "pkgs",
                                                                                                                           position: (441, 68),
                                                                                                                          },
                                                                                                                          attribute_path: AttributePath {
                                                                                                                           attributes: [
                                                                                                                            Raw {
                                                                                                                             content: "sssd",
                                                                                                                             position: (441, 73),
                                                                                                                            },
                                                                                                                           ],
                                                                                                                          },
                                                                                                                          default: None,
                                                                                                                         },
                                                                                                                        },
                                                                                                                        Raw {
                                                                                                                         content: "/lib/security/pam_sss.so\n",
                                                                                                                         position: (441, 78),
                                                                                                                        },
                                                                                                                       ],
                                                                                                                      },
                                                                                                                     ],
                                                                                                                    },
                                                                                                                   ],
                                                                                                                   position: (439, 14),
                                                                                                                  },
                                                                                                                  FunctionApplication {
                                                                                                                   function: Variable {
                                                                                                                    identifier: "optionalString",
                                                                                                                    position: (443, 11),
                                                                                                                   },
                                                                                                                   arguments: [
                                                                                                                    PropertyAccess {
                                                                                                                     expression: Variable {
                                                                                                                      identifier: "config",
                                                                                                                      position: (443, 26),
                                                                                                                     },
                                                                                                                     attribute_path: AttributePath {
                                                                                                                      attributes: [
                                                                                                                       Raw {
                                                                                                                        content: "krb5",
                                                                                                                        position: (443, 33),
                                                                                                                       },
                                                                                                                       Raw {
                                                                                                                        content: "enable",
                                                                                                                        position: (443, 38),
                                                                                                                       },
                                                                                                                      ],
                                                                                                                     },
                                                                                                                     default: None,
                                                                                                                    },
                                                                                                                    String {
                                                                                                                     parts: [
                                                                                                                      Raw {
                                                                                                                       content: "account sufficient ",
                                                                                                                       position: (444, 1),
                                                                                                                      },
                                                                                                                      Expression {
                                                                                                                       expression: Variable {
                                                                                                                        identifier: "pam_krb5",
                                                                                                                        position: (444, 34),
                                                                                                                       },
                                                                                                                      },
                                                                                                                      Raw {
                                                                                                                       content: "/lib/security/pam_krb5.so\n",
                                                                                                                       position: (444, 43),
                                                                                                                      },
                                                                                                                     ],
                                                                                                                    },
                                                                                                                   ],
                                                                                                                  },
                                                                                                                 ],
                                                                                                                 position: (442, 14),
                                                                                                                },
                                                                                                                FunctionApplication {
                                                                                                                 function: Variable {
                                                                                                                  identifier: "optionalString",
                                                                                                                  position: (446, 11),
                                                                                                                 },
                                                                                                                 arguments: [
                                                                                                                  PropertyAccess {
                                                                                                                   expression: Variable {
                                                                                                                    identifier: "cfg",
                                                                                                                    position: (446, 26),
                                                                                                                   },
                                                                                                                   attribute_path: AttributePath {
                                                                                                                    attributes: [
                                                                                                                     Raw {
                                                                                                                      content: "googleOsLoginAccountVerification",
                                                                                                                      position: (446, 30),
                                                                                                                     },
                                                                                                                    ],
                                                                                                                   },
                                                                                                                   default: None,
                                                                                                                  },
                                                                                                                  String {
                                                                                                                   parts: [
                                                                                                                    Raw {
                                                                                                                     content: "account [success=ok ignore=ignore default=die] ",
                                                                                                                     position: (447, 1),
                                                                                                                    },
                                                                                                                    Expression {
                                                                                                                     expression: PropertyAccess {
                                                                                                                      expression: Variable {
                                                                                                                       identifier: "pkgs",
                                                                                                                       position: (447, 62),
                                                                                                                      },
                                                                                                                      attribute_path: AttributePath {
                                                                                                                       attributes: [
                                                                                                                        Raw {
                                                                                                                         content: "google-guest-oslogin",
                                                                                                                         position: (447, 67),
                                                                                                                        },
                                                                                                                       ],
                                                                                                                      },
                                                                                                                      default: None,
                                                                                                                     },
                                                                                                                    },
                                                                                                                    Raw {
                                                                                                                     content: "/lib/security/pam_oslogin_login.so\naccount [success=ok default=ignore] ",
                                                                                                                     position: (447, 88),
                                                                                                                    },
                                                                                                                    Expression {
                                                                                                                     expression: PropertyAccess {
                                                                                                                      expression: Variable {
                                                                                                                       identifier: "pkgs",
                                                                                                                       position: (448, 51),
                                                                                                                      },
                                                                                                                      attribute_path: AttributePath {
                                                                                                                       attributes: [
                                                                                                                        Raw {
                                                                                                                         content: "google-guest-oslogin",
                                                                                                                         position: (448, 56),
                                                                                                                        },
                                                                                                                       ],
                                                                                                                      },
                                                                                                                      default: None,
                                                                                                                     },
                                                                                                                    },
                                                                                                                    Raw {
                                                                                                                     content: "/lib/security/pam_oslogin_admin.so\n",
                                                                                                                     position: (448, 77),
                                                                                                                    },
                                                                                                                   ],
                                                                                                                  },
                                                                                                                 ],
                                                                                                                },
                                                                                                               ],
                                                                                                               position: (445, 14),
                                                                                                              },
                                                                                                              String {
                                                                                                               parts: [
                                                                                                                Raw {
                                                                                                                 content: "\n# Authentication management.\n",
                                                                                                                 position: (451, 1),
                                                                                                                },
                                                                                                               ],
                                                                                                              },
                                                                                                             ],
                                                                                                             position: (449, 14),
                                                                                                            },
                                                                                                            FunctionApplication {
                                                                                                             function: Variable {
                                                                                                              identifier: "optionalString",
                                                                                                              position: (454, 11),
                                                                                                             },
                                                                                                             arguments: [
                                                                                                              PropertyAccess {
                                                                                                               expression: Variable {
                                                                                                                identifier: "cfg",
                                                                                                                position: (454, 26),
                                                                                                               },
                                                                                                               attribute_path: AttributePath {
                                                                                                                attributes: [
                                                                                                                 Raw {
                                                                                                                  content: "googleOsLoginAuthentication",
                                                                                                                  position: (454, 30),
                                                                                                                 },
                                                                                                                ],
                                                                                                               },
                                                                                                               default: None,
                                                                                                              },
                                                                                                              String {
                                                                                                               parts: [
                                                                                                                Raw {
                                                                                                                 content: "auth [success=done perm_denied=die default=ignore] ",
                                                                                                                 position: (455, 1),
                                                                                                                },
                                                                                                                Expression {
                                                                                                                 expression: PropertyAccess {
                                                                                                                  expression: Variable {
                                                                                                                   identifier: "pkgs",
                                                                                                                   position: (455, 66),
                                                                                                                  },
                                                                                                                  attribute_path: AttributePath {
                                                                                                                   attributes: [
                                                                                                                    Raw {
                                                                                                                     content: "google-guest-oslogin",
                                                                                                                     position: (455, 71),
                                                                                                                    },
                                                                                                                   ],
                                                                                                                  },
                                                                                                                  default: None,
                                                                                                                 },
                                                                                                                },
                                                                                                                Raw {
                                                                                                                 content: "/lib/security/pam_oslogin_login.so\n",
                                                                                                                 position: (455, 92),
                                                                                                                },
                                                                                                               ],
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (453, 14),
                                                                                                          },
                                                                                                          FunctionApplication {
                                                                                                           function: Variable {
                                                                                                            identifier: "optionalString",
                                                                                                            position: (457, 11),
                                                                                                           },
                                                                                                           arguments: [
                                                                                                            PropertyAccess {
                                                                                                             expression: Variable {
                                                                                                              identifier: "cfg",
                                                                                                              position: (457, 26),
                                                                                                             },
                                                                                                             attribute_path: AttributePath {
                                                                                                              attributes: [
                                                                                                               Raw {
                                                                                                                content: "rootOK",
                                                                                                                position: (457, 30),
                                                                                                               },
                                                                                                              ],
                                                                                                             },
                                                                                                             default: None,
                                                                                                            },
                                                                                                            String {
                                                                                                             parts: [
                                                                                                              Raw {
                                                                                                               content: "auth sufficient pam_rootok.so\n",
                                                                                                               position: (458, 1),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (456, 14),
                                                                                                        },
                                                                                                        FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (460, 11),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "cfg",
                                                                                                            position: (460, 26),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "requireWheel",
                                                                                                              position: (460, 30),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "auth required pam_wheel.so use_uid\n",
                                                                                                             position: (461, 1),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (459, 14),
                                                                                                      },
                                                                                                      FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (463, 11),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "cfg",
                                                                                                          position: (463, 26),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "logFailures",
                                                                                                            position: (463, 30),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "auth required pam_faillock.so\n",
                                                                                                           position: (464, 1),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (462, 14),
                                                                                                    },
                                                                                                    FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (466, 11),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      BinaryOperation {
                                                                                                       operator: LogicalAnd,
                                                                                                       operands: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "config",
                                                                                                          position: (466, 27),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "security",
                                                                                                            position: (466, 34),
                                                                                                           },
                                                                                                           Raw {
                                                                                                            content: "pam",
                                                                                                            position: (466, 43),
                                                                                                           },
                                                                                                           Raw {
                                                                                                            content: "enableSSHAgentAuth",
                                                                                                            position: (466, 47),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "cfg",
                                                                                                          position: (466, 69),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "sshAgentAuth",
                                                                                                            position: (466, 73),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (466, 66),
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "auth sufficient ",
                                                                                                         position: (467, 1),
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "pkgs",
                                                                                                           position: (467, 31),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "pam_ssh_agent_auth",
                                                                                                             position: (467, 36),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "/libexec/pam_ssh_agent_auth.so file=",
                                                                                                         position: (467, 55),
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: FunctionApplication {
                                                                                                          function: PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "lib",
                                                                                                            position: (467, 93),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "concatStringsSep",
                                                                                                              position: (467, 97),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          arguments: [
                                                                                                           String {
                                                                                                            parts: [
                                                                                                             Raw {
                                                                                                              content: ":",
                                                                                                              position: (467, 115),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "config",
                                                                                                             position: (467, 118),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "services",
                                                                                                               position: (467, 125),
                                                                                                              },
                                                                                                              Raw {
                                                                                                               content: "openssh",
                                                                                                               position: (467, 134),
                                                                                                              },
                                                                                                              Raw {
                                                                                                               content: "authorizedKeysFiles",
                                                                                                               position: (467, 142),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "\n",
                                                                                                         position: (467, 162),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (465, 14),
                                                                                                  },
                                                                                                  LetIn {
                                                                                                   bindings: [
                                                                                                    KeyValue(
                                                                                                     AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "p11",
                                                                                                        position: (469, 16),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "config",
                                                                                                       position: (469, 22),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "security",
                                                                                                         position: (469, 29),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "pam",
                                                                                                         position: (469, 38),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "p11",
                                                                                                         position: (469, 42),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    ),
                                                                                                   ],
                                                                                                   target: FunctionApplication {
                                                                                                    function: Variable {
                                                                                                     identifier: "optionalString",
                                                                                                     position: (469, 50),
                                                                                                    },
                                                                                                    arguments: [
                                                                                                     PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "cfg",
                                                                                                       position: (469, 65),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "p11Auth",
                                                                                                         position: (469, 69),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                     String {
                                                                                                      parts: [
                                                                                                       Raw {
                                                                                                        content: "auth ",
                                                                                                        position: (470, 1),
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "p11",
                                                                                                          position: (470, 20),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "control",
                                                                                                            position: (470, 24),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: " ",
                                                                                                        position: (470, 32),
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "pkgs",
                                                                                                          position: (470, 35),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "pam_p11",
                                                                                                            position: (470, 40),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: "/lib/security/pam_p11.so ",
                                                                                                        position: (470, 48),
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "pkgs",
                                                                                                          position: (470, 75),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "opensc",
                                                                                                            position: (470, 80),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: "/lib/opensc-pkcs11.so\n",
                                                                                                        position: (470, 87),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   position: (469, 12),
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (468, 14),
                                                                                                },
                                                                                                LetIn {
                                                                                                 bindings: [
                                                                                                  KeyValue(
                                                                                                   AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "u2f",
                                                                                                      position: (472, 16),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "config",
                                                                                                     position: (472, 22),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "security",
                                                                                                       position: (472, 29),
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "pam",
                                                                                                       position: (472, 38),
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "u2f",
                                                                                                       position: (472, 42),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                  ),
                                                                                                 ],
                                                                                                 target: FunctionApplication {
                                                                                                  function: Variable {
                                                                                                   identifier: "optionalString",
                                                                                                   position: (472, 50),
                                                                                                  },
                                                                                                  arguments: [
                                                                                                   PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "cfg",
                                                                                                     position: (472, 65),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "u2fAuth",
                                                                                                       position: (472, 69),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                   String {
                                                                                                    parts: [
                                                                                                     Raw {
                                                                                                      content: "auth ",
                                                                                                      position: (473, 1),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "u2f",
                                                                                                        position: (473, 20),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "control",
                                                                                                          position: (473, 24),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: " ",
                                                                                                      position: (473, 32),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "pkgs",
                                                                                                        position: (473, 35),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "pam_u2f",
                                                                                                          position: (473, 40),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: "/lib/security/pam_u2f.so ",
                                                                                                      position: (473, 48),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (473, 75),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "u2f",
                                                                                                          position: (473, 90),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "debug",
                                                                                                            position: (473, 94),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "debug",
                                                                                                           position: (473, 101),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: " ",
                                                                                                      position: (473, 108),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (473, 111),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        BinaryOperation {
                                                                                                         operator: NotEqualTo,
                                                                                                         operands: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "u2f",
                                                                                                            position: (473, 127),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "authFile",
                                                                                                              position: (473, 131),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          Variable {
                                                                                                           identifier: "null",
                                                                                                           position: (473, 143),
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (473, 140),
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "authfile=",
                                                                                                           position: (473, 150),
                                                                                                          },
                                                                                                          Expression {
                                                                                                           expression: PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "u2f",
                                                                                                             position: (473, 161),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "authFile",
                                                                                                               position: (473, 165),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: " ",
                                                                                                      position: (473, 176),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (473, 179),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "u2f",
                                                                                                          position: (473, 194),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "interactive",
                                                                                                            position: (473, 198),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "interactive",
                                                                                                           position: (473, 211),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: " ",
                                                                                                      position: (473, 224),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (473, 227),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "u2f",
                                                                                                          position: (473, 242),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "cue",
                                                                                                            position: (473, 246),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "cue",
                                                                                                           position: (473, 251),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: " ",
                                                                                                      position: (473, 256),
                                                                                                     },
                                                                                                     Expression {
                                                                                                      expression: FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (473, 259),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        BinaryOperation {
                                                                                                         operator: NotEqualTo,
                                                                                                         operands: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "u2f",
                                                                                                            position: (473, 275),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "appId",
                                                                                                              position: (473, 279),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          Variable {
                                                                                                           identifier: "null",
                                                                                                           position: (473, 288),
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (473, 285),
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "appid=",
                                                                                                           position: (473, 295),
                                                                                                          },
                                                                                                          Expression {
                                                                                                           expression: PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "u2f",
                                                                                                             position: (473, 303),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "appId",
                                                                                                               position: (473, 307),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     },
                                                                                                     Raw {
                                                                                                      content: "\n",
                                                                                                      position: (473, 315),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 position: (472, 12),
                                                                                                },
                                                                                               ],
                                                                                               position: (471, 15),
                                                                                              },
                                                                                              FunctionApplication {
                                                                                               function: Variable {
                                                                                                identifier: "optionalString",
                                                                                                position: (475, 11),
                                                                                               },
                                                                                               arguments: [
                                                                                                PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "cfg",
                                                                                                  position: (475, 26),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "usbAuth",
                                                                                                    position: (475, 30),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                                String {
                                                                                                 parts: [
                                                                                                  Raw {
                                                                                                   content: "auth sufficient ",
                                                                                                   position: (476, 1),
                                                                                                  },
                                                                                                  Expression {
                                                                                                   expression: PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "pkgs",
                                                                                                     position: (476, 31),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "pam_usb",
                                                                                                       position: (476, 36),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "/lib/security/pam_usb.so\n",
                                                                                                   position: (476, 44),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                             ],
                                                                                             position: (474, 15),
                                                                                            },
                                                                                            LetIn {
                                                                                             bindings: [
                                                                                              KeyValue(
                                                                                               AttributePath {
                                                                                                attributes: [
                                                                                                 Raw {
                                                                                                  content: "oath",
                                                                                                  position: (478, 16),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               PropertyAccess {
                                                                                                expression: Variable {
                                                                                                 identifier: "config",
                                                                                                 position: (478, 23),
                                                                                                },
                                                                                                attribute_path: AttributePath {
                                                                                                 attributes: [
                                                                                                  Raw {
                                                                                                   content: "security",
                                                                                                   position: (478, 30),
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "pam",
                                                                                                   position: (478, 39),
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "oath",
                                                                                                   position: (478, 43),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                                default: None,
                                                                                               },
                                                                                              ),
                                                                                             ],
                                                                                             target: FunctionApplication {
                                                                                              function: Variable {
                                                                                               identifier: "optionalString",
                                                                                               position: (478, 52),
                                                                                              },
                                                                                              arguments: [
                                                                                               PropertyAccess {
                                                                                                expression: Variable {
                                                                                                 identifier: "cfg",
                                                                                                 position: (478, 67),
                                                                                                },
                                                                                                attribute_path: AttributePath {
                                                                                                 attributes: [
                                                                                                  Raw {
                                                                                                   content: "oathAuth",
                                                                                                   position: (478, 71),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                                default: None,
                                                                                               },
                                                                                               String {
                                                                                                parts: [
                                                                                                 Raw {
                                                                                                  content: "auth requisite ",
                                                                                                  position: (479, 1),
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "pkgs",
                                                                                                    position: (479, 30),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "oathToolkit",
                                                                                                      position: (479, 35),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "/lib/security/pam_oath.so window=",
                                                                                                  position: (479, 47),
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "toString",
                                                                                                    position: (479, 82),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "oath",
                                                                                                      position: (479, 91),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "window",
                                                                                                        position: (479, 96),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: " usersfile=",
                                                                                                  position: (479, 103),
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "toString",
                                                                                                    position: (479, 116),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "oath",
                                                                                                      position: (479, 125),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "usersFile",
                                                                                                        position: (479, 130),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: " digits=",
                                                                                                  position: (479, 140),
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "toString",
                                                                                                    position: (479, 150),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "oath",
                                                                                                      position: (479, 159),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "digits",
                                                                                                        position: (479, 164),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "\n",
                                                                                                  position: (479, 171),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             position: (478, 12),
                                                                                            },
                                                                                           ],
                                                                                           position: (477, 14),
                                                                                          },
                                                                                          LetIn {
                                                                                           bindings: [
                                                                                            KeyValue(
                                                                                             AttributePath {
                                                                                              attributes: [
                                                                                               Raw {
                                                                                                content: "yubi",
                                                                                                position: (481, 16),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             PropertyAccess {
                                                                                              expression: Variable {
                                                                                               identifier: "config",
                                                                                               position: (481, 23),
                                                                                              },
                                                                                              attribute_path: AttributePath {
                                                                                               attributes: [
                                                                                                Raw {
                                                                                                 content: "security",
                                                                                                 position: (481, 30),
                                                                                                },
                                                                                                Raw {
                                                                                                 content: "pam",
                                                                                                 position: (481, 39),
                                                                                                },
                                                                                                Raw {
                                                                                                 content: "yubico",
                                                                                                 position: (481, 43),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                              default: None,
                                                                                             },
                                                                                            ),
                                                                                           ],
                                                                                           target: FunctionApplication {
                                                                                            function: Variable {
                                                                                             identifier: "optionalString",
                                                                                             position: (481, 54),
                                                                                            },
                                                                                            arguments: [
                                                                                             PropertyAccess {
                                                                                              expression: Variable {
                                                                                               identifier: "cfg",
                                                                                               position: (481, 69),
                                                                                              },
                                                                                              attribute_path: AttributePath {
                                                                                               attributes: [
                                                                                                Raw {
                                                                                                 content: "yubicoAuth",
                                                                                                 position: (481, 73),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                              default: None,
                                                                                             },
                                                                                             String {
                                                                                              parts: [
                                                                                               Raw {
                                                                                                content: "auth ",
                                                                                                position: (482, 1),
                                                                                               },
                                                                                               Expression {
                                                                                                expression: PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "yubi",
                                                                                                  position: (482, 20),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "control",
                                                                                                    position: (482, 25),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                                position: (482, 33),
                                                                                               },
                                                                                               Expression {
                                                                                                expression: PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "pkgs",
                                                                                                  position: (482, 36),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "yubico-pam",
                                                                                                    position: (482, 41),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: "/lib/security/pam_yubico.so mode=",
                                                                                                position: (482, 52),
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "toString",
                                                                                                  position: (482, 87),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "yubi",
                                                                                                    position: (482, 96),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "mode",
                                                                                                      position: (482, 101),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                                position: (482, 106),
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (482, 109),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  BinaryOperation {
                                                                                                   operator: NotEqualTo,
                                                                                                   operands: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "yubi",
                                                                                                      position: (482, 125),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "challengeResponsePath",
                                                                                                        position: (482, 130),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                    Variable {
                                                                                                     identifier: "null",
                                                                                                     position: (482, 155),
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (482, 152),
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "chalresp_path=",
                                                                                                     position: (482, 162),
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "yubi",
                                                                                                       position: (482, 178),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "challengeResponsePath",
                                                                                                         position: (482, 183),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                                position: (482, 207),
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (482, 210),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  BinaryOperation {
                                                                                                   operator: EqualTo,
                                                                                                   operands: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "yubi",
                                                                                                      position: (482, 226),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "mode",
                                                                                                        position: (482, 231),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                    String {
                                                                                                     parts: [
                                                                                                      Raw {
                                                                                                       content: "client",
                                                                                                       position: (482, 240),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (482, 236),
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "id=",
                                                                                                     position: (482, 250),
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: FunctionApplication {
                                                                                                      function: Variable {
                                                                                                       identifier: "toString",
                                                                                                       position: (482, 255),
                                                                                                      },
                                                                                                      arguments: [
                                                                                                       PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "yubi",
                                                                                                         position: (482, 264),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "id",
                                                                                                           position: (482, 269),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                                position: (482, 274),
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (482, 277),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "yubi",
                                                                                                    position: (482, 292),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "debug",
                                                                                                      position: (482, 297),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "debug",
                                                                                                     position: (482, 304),
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: "\n",
                                                                                                position: (482, 311),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                           position: (481, 12),
                                                                                          },
                                                                                         ],
                                                                                         position: (480, 15),
                                                                                        },
                                                                                        FunctionApplication {
                                                                                         function: Variable {
                                                                                          identifier: "optionalString",
                                                                                          position: (484, 11),
                                                                                         },
                                                                                         arguments: [
                                                                                          PropertyAccess {
                                                                                           expression: Variable {
                                                                                            identifier: "cfg",
                                                                                            position: (484, 26),
                                                                                           },
                                                                                           attribute_path: AttributePath {
                                                                                            attributes: [
                                                                                             Raw {
                                                                                              content: "fprintAuth",
                                                                                              position: (484, 30),
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                           default: None,
                                                                                          },
                                                                                          String {
                                                                                           parts: [
                                                                                            Raw {
                                                                                             content: "auth sufficient ",
                                                                                             position: (485, 1),
                                                                                            },
                                                                                            Expression {
                                                                                             expression: PropertyAccess {
                                                                                              expression: Variable {
                                                                                               identifier: "pkgs",
                                                                                               position: (485, 31),
                                                                                              },
                                                                                              attribute_path: AttributePath {
                                                                                               attributes: [
                                                                                                Raw {
                                                                                                 content: "fprintd",
                                                                                                 position: (485, 36),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                              default: None,
                                                                                             },
                                                                                            },
                                                                                            Raw {
                                                                                             content: "/lib/security/pam_fprintd.so\n",
                                                                                             position: (485, 44),
                                                                                            },
                                                                                           ],
                                                                                          },
                                                                                         ],
                                                                                        },
                                                                                       ],
                                                                                       position: (483, 15),
                                                                                      },
                                                                                      FunctionApplication {
                                                                                       function: Variable {
                                                                                        identifier: "optionalString",
                                                                                        position: (493, 12),
                                                                                       },
                                                                                       arguments: [
                                                                                        BinaryOperation {
                                                                                         operator: LogicalAnd,
                                                                                         operands: [
                                                                                          PropertyAccess {
                                                                                           expression: Variable {
                                                                                            identifier: "cfg",
                                                                                            position: (493, 28),
                                                                                           },
                                                                                           attribute_path: AttributePath {
                                                                                            attributes: [
                                                                                             Raw {
                                                                                              content: "unixAuth",
                                                                                              position: (493, 32),
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                           default: None,
                                                                                          },
                                                                                          BinaryOperation {
                                                                                           operator: LogicalOr,
                                                                                           operands: [
                                                                                            BinaryOperation {
                                                                                             operator: LogicalOr,
                                                                                             operands: [
                                                                                              BinaryOperation {
                                                                                               operator: LogicalOr,
                                                                                               operands: [
                                                                                                BinaryOperation {
                                                                                                 operator: LogicalOr,
                                                                                                 operands: [
                                                                                                  BinaryOperation {
                                                                                                   operator: LogicalOr,
                                                                                                   operands: [
                                                                                                    BinaryOperation {
                                                                                                     operator: LogicalOr,
                                                                                                     operands: [
                                                                                                      PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "config",
                                                                                                        position: (494, 14),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "security",
                                                                                                          position: (494, 21),
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: "pam",
                                                                                                          position: (494, 30),
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: "enableEcryptfs",
                                                                                                          position: (494, 34),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                      PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "cfg",
                                                                                                        position: (495, 18),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "pamMount",
                                                                                                          position: (495, 22),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (495, 15),
                                                                                                    },
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "cfg",
                                                                                                      position: (496, 18),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "enableKwallet",
                                                                                                        position: (496, 22),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (496, 15),
                                                                                                  },
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "cfg",
                                                                                                    position: (497, 18),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "enableGnomeKeyring",
                                                                                                      position: (497, 22),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (497, 15),
                                                                                                },
                                                                                                PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "cfg",
                                                                                                  position: (498, 18),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "googleAuthenticator",
                                                                                                    position: (498, 22),
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: "enable",
                                                                                                    position: (498, 42),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                               ],
                                                                                               position: (498, 15),
                                                                                              },
                                                                                              PropertyAccess {
                                                                                               expression: Variable {
                                                                                                identifier: "cfg",
                                                                                                position: (499, 18),
                                                                                               },
                                                                                               attribute_path: AttributePath {
                                                                                                attributes: [
                                                                                                 Raw {
                                                                                                  content: "gnupg",
                                                                                                  position: (499, 22),
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "enable",
                                                                                                  position: (499, 28),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               default: None,
                                                                                              },
                                                                                             ],
                                                                                             position: (499, 15),
                                                                                            },
                                                                                            PropertyAccess {
                                                                                             expression: Variable {
                                                                                              identifier: "cfg",
                                                                                              position: (500, 18),
                                                                                             },
                                                                                             attribute_path: AttributePath {
                                                                                              attributes: [
                                                                                               Raw {
                                                                                                content: "duoSecurity",
                                                                                                position: (500, 22),
                                                                                               },
                                                                                               Raw {
                                                                                                content: "enable",
                                                                                                position: (500, 34),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             default: None,
                                                                                            },
                                                                                           ],
                                                                                           position: (500, 15),
                                                                                          },
                                                                                         ],
                                                                                         position: (493, 41),
                                                                                        },
                                                                                        BinaryOperation {
                                                                                         operator: Addition,
                                                                                         operands: [
                                                                                          BinaryOperation {
                                                                                           operator: Addition,
                                                                                           operands: [
                                                                                            BinaryOperation {
                                                                                             operator: Addition,
                                                                                             operands: [
                                                                                              BinaryOperation {
                                                                                               operator: Addition,
                                                                                               operands: [
                                                                                                BinaryOperation {
                                                                                                 operator: Addition,
                                                                                                 operands: [
                                                                                                  BinaryOperation {
                                                                                                   operator: Addition,
                                                                                                   operands: [
                                                                                                    BinaryOperation {
                                                                                                     operator: Addition,
                                                                                                     operands: [
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "auth required pam_unix.so ",
                                                                                                         position: (503, 1),
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: FunctionApplication {
                                                                                                          function: Variable {
                                                                                                           identifier: "optionalString",
                                                                                                           position: (503, 45),
                                                                                                          },
                                                                                                          arguments: [
                                                                                                           PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "cfg",
                                                                                                             position: (503, 60),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "allowNullPassword",
                                                                                                               position: (503, 64),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                           String {
                                                                                                            parts: [
                                                                                                             Raw {
                                                                                                              content: "nullok",
                                                                                                              position: (503, 83),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: " ",
                                                                                                         position: (503, 91),
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: FunctionApplication {
                                                                                                          function: Variable {
                                                                                                           identifier: "optionalString",
                                                                                                           position: (503, 94),
                                                                                                          },
                                                                                                          arguments: [
                                                                                                           PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "cfg",
                                                                                                             position: (503, 109),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "nodelay",
                                                                                                               position: (503, 113),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                           String {
                                                                                                            parts: [
                                                                                                             Raw {
                                                                                                              content: "nodelay",
                                                                                                              position: (503, 122),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: " likeauth\n",
                                                                                                         position: (503, 131),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (505, 15),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "config",
                                                                                                          position: (505, 30),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "security",
                                                                                                            position: (505, 37),
                                                                                                           },
                                                                                                           Raw {
                                                                                                            content: "pam",
                                                                                                            position: (505, 46),
                                                                                                           },
                                                                                                           Raw {
                                                                                                            content: "enableEcryptfs",
                                                                                                            position: (505, 50),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "auth optional ",
                                                                                                           position: (506, 1),
                                                                                                          },
                                                                                                          Expression {
                                                                                                           expression: PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "pkgs",
                                                                                                             position: (506, 33),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "ecryptfs",
                                                                                                               position: (506, 38),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "/lib/security/pam_ecryptfs.so unwrap\n",
                                                                                                           position: (506, 47),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (504, 18),
                                                                                                    },
                                                                                                    FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (508, 15),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "cfg",
                                                                                                        position: (508, 30),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "pamMount",
                                                                                                          position: (508, 34),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "auth optional ",
                                                                                                         position: (509, 1),
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "pkgs",
                                                                                                           position: (509, 33),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "pam_mount",
                                                                                                             position: (509, 38),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "/lib/security/pam_mount.so disable_interactive\n",
                                                                                                         position: (509, 48),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (507, 18),
                                                                                                  },
                                                                                                  FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "optionalString",
                                                                                                    position: (511, 15),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "cfg",
                                                                                                      position: (511, 30),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "enableKwallet",
                                                                                                        position: (511, 34),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                    String {
                                                                                                     parts: [
                                                                                                      Raw {
                                                                                                       content: "auth optional ",
                                                                                                       position: (512, 1),
                                                                                                      },
                                                                                                      Expression {
                                                                                                       expression: PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "pkgs",
                                                                                                         position: (512, 32),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "plasma5Packages",
                                                                                                           position: (512, 37),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "kwallet-pam",
                                                                                                           position: (512, 53),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "/lib/security/pam_kwallet5.so kwalletd=",
                                                                                                       position: (512, 65),
                                                                                                      },
                                                                                                      Expression {
                                                                                                       expression: PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "pkgs",
                                                                                                         position: (512, 106),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "plasma5Packages",
                                                                                                           position: (512, 111),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "kwallet",
                                                                                                           position: (512, 127),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "bin",
                                                                                                           position: (512, 135),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "/bin/kwalletd5\n",
                                                                                                       position: (512, 139),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (510, 18),
                                                                                                },
                                                                                                FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (514, 15),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "cfg",
                                                                                                    position: (514, 30),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "enableGnomeKeyring",
                                                                                                      position: (514, 34),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "auth optional ",
                                                                                                     position: (515, 1),
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "pkgs",
                                                                                                       position: (515, 33),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "gnome",
                                                                                                         position: (515, 38),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "gnome-keyring",
                                                                                                         position: (515, 44),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    },
                                                                                                    Raw {
                                                                                                     content: "/lib/security/pam_gnome_keyring.so\n",
                                                                                                     position: (515, 58),
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               ],
                                                                                               position: (513, 18),
                                                                                              },
                                                                                              FunctionApplication {
                                                                                               function: Variable {
                                                                                                identifier: "optionalString",
                                                                                                position: (517, 15),
                                                                                               },
                                                                                               arguments: [
                                                                                                PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "cfg",
                                                                                                  position: (517, 30),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "gnupg",
                                                                                                    position: (517, 34),
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: "enable",
                                                                                                    position: (517, 40),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                                String {
                                                                                                 parts: [
                                                                                                  Raw {
                                                                                                   content: "auth optional ",
                                                                                                   position: (518, 1),
                                                                                                  },
                                                                                                  Expression {
                                                                                                   expression: PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "pkgs",
                                                                                                     position: (518, 33),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "pam_gnupg",
                                                                                                       position: (518, 38),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "/lib/security/pam_gnupg.so ",
                                                                                                   position: (518, 48),
                                                                                                  },
                                                                                                  Expression {
                                                                                                   expression: FunctionApplication {
                                                                                                    function: Variable {
                                                                                                     identifier: "optionalString",
                                                                                                     position: (518, 77),
                                                                                                    },
                                                                                                    arguments: [
                                                                                                     PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "cfg",
                                                                                                       position: (518, 92),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "gnupg",
                                                                                                         position: (518, 96),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "storeOnly",
                                                                                                         position: (518, 102),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                     String {
                                                                                                      parts: [
                                                                                                       Raw {
                                                                                                        content: " store-only",
                                                                                                        position: (518, 113),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "\n",
                                                                                                   position: (518, 126),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                             ],
                                                                                             position: (516, 18),
                                                                                            },
                                                                                            FunctionApplication {
                                                                                             function: Variable {
                                                                                              identifier: "optionalString",
                                                                                              position: (520, 15),
                                                                                             },
                                                                                             arguments: [
                                                                                              PropertyAccess {
                                                                                               expression: Variable {
                                                                                                identifier: "cfg",
                                                                                                position: (520, 30),
                                                                                               },
                                                                                               attribute_path: AttributePath {
                                                                                                attributes: [
                                                                                                 Raw {
                                                                                                  content: "googleAuthenticator",
                                                                                                  position: (520, 34),
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "enable",
                                                                                                  position: (520, 54),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               default: None,
                                                                                              },
                                                                                              String {
                                                                                               parts: [
                                                                                                Raw {
                                                                                                 content: "auth required ",
                                                                                                 position: (521, 1),
                                                                                                },
                                                                                                Expression {
                                                                                                 expression: PropertyAccess {
                                                                                                  expression: Variable {
                                                                                                   identifier: "pkgs",
                                                                                                   position: (521, 33),
                                                                                                  },
                                                                                                  attribute_path: AttributePath {
                                                                                                   attributes: [
                                                                                                    Raw {
                                                                                                     content: "googleAuthenticator",
                                                                                                     position: (521, 38),
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                  default: None,
                                                                                                 },
                                                                                                },
                                                                                                Raw {
                                                                                                 content: "/lib/security/pam_google_authenticator.so no_increment_hotp\n",
                                                                                                 position: (521, 58),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                           ],
                                                                                           position: (519, 18),
                                                                                          },
                                                                                          FunctionApplication {
                                                                                           function: Variable {
                                                                                            identifier: "optionalString",
                                                                                            position: (523, 15),
                                                                                           },
                                                                                           arguments: [
                                                                                            PropertyAccess {
                                                                                             expression: Variable {
                                                                                              identifier: "cfg",
                                                                                              position: (523, 30),
                                                                                             },
                                                                                             attribute_path: AttributePath {
                                                                                              attributes: [
                                                                                               Raw {
                                                                                                content: "duoSecurity",
                                                                                                position: (523, 34),
                                                                                               },
                                                                                               Raw {
                                                                                                content: "enable",
                                                                                                position: (523, 46),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             default: None,
                                                                                            },
                                                                                            String {
                                                                                             parts: [
                                                                                              Raw {
                                                                                               content: "auth required ",
                                                                                               position: (524, 1),
                                                                                              },
                                                                                              Expression {
                                                                                               expression: PropertyAccess {
                                                                                                expression: Variable {
                                                                                                 identifier: "pkgs",
                                                                                                 position: (524, 33),
                                                                                                },
                                                                                                attribute_path: AttributePath {
                                                                                                 attributes: [
                                                                                                  Raw {
                                                                                                   content: "duo-unix",
                                                                                                   position: (524, 38),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                                default: None,
                                                                                               },
                                                                                              },
                                                                                              Raw {
                                                                                               content: "/lib/security/pam_duo.so\n",
                                                                                               position: (524, 47),
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                           ],
                                                                                          },
                                                                                         ],
                                                                                         position: (522, 18),
                                                                                        },
                                                                                       ],
                                                                                      },
                                                                                     ],
                                                                                     position: (486, 14),
                                                                                    },
                                                                                    FunctionApplication {
                                                                                     function: Variable {
                                                                                      identifier: "optionalString",
                                                                                      position: (527, 11),
                                                                                     },
                                                                                     arguments: [
                                                                                      PropertyAccess {
                                                                                       expression: Variable {
                                                                                        identifier: "cfg",
                                                                                        position: (527, 26),
                                                                                       },
                                                                                       attribute_path: AttributePath {
                                                                                        attributes: [
                                                                                         Raw {
                                                                                          content: "unixAuth",
                                                                                          position: (527, 30),
                                                                                         },
                                                                                        ],
                                                                                       },
                                                                                       default: None,
                                                                                      },
                                                                                      String {
                                                                                       parts: [
                                                                                        Raw {
                                                                                         content: "auth sufficient pam_unix.so ",
                                                                                         position: (528, 1),
                                                                                        },
                                                                                        Expression {
                                                                                         expression: FunctionApplication {
                                                                                          function: Variable {
                                                                                           identifier: "optionalString",
                                                                                           position: (528, 43),
                                                                                          },
                                                                                          arguments: [
                                                                                           PropertyAccess {
                                                                                            expression: Variable {
                                                                                             identifier: "cfg",
                                                                                             position: (528, 58),
                                                                                            },
                                                                                            attribute_path: AttributePath {
                                                                                             attributes: [
                                                                                              Raw {
                                                                                               content: "allowNullPassword",
                                                                                               position: (528, 62),
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                            default: None,
                                                                                           },
                                                                                           String {
                                                                                            parts: [
                                                                                             Raw {
                                                                                              content: "nullok",
                                                                                              position: (528, 81),
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                          ],
                                                                                         },
                                                                                        },
                                                                                        Raw {
                                                                                         content: " ",
                                                                                         position: (528, 89),
                                                                                        },
                                                                                        Expression {
                                                                                         expression: FunctionApplication {
                                                                                          function: Variable {
                                                                                           identifier: "optionalString",
                                                                                           position: (528, 92),
                                                                                          },
                                                                                          arguments: [
                                                                                           PropertyAccess {
                                                                                            expression: Variable {
                                                                                             identifier: "cfg",
                                                                                             position: (528, 107),
                                                                                            },
                                                                                            attribute_path: AttributePath {
                                                                                             attributes: [
                                                                                              Raw {
                                                                                               content: "nodelay",
                                                                                               position: (528, 111),
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                            default: None,
                                                                                           },
                                                                                           String {
                                                                                            parts: [
                                                                                             Raw {
                                                                                              content: "nodelay",
                                                                                              position: (528, 120),
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                          ],
                                                                                         },
                                                                                        },
                                                                                        Raw {
                                                                                         content: " likeauth try_first_pass\n",
                                                                                         position: (528, 129),
                                                                                        },
                                                                                       ],
                                                                                      },
                                                                                     ],
                                                                                    },
                                                                                   ],
                                                                                   position: (526, 16),
                                                                                  },
                                                                                  FunctionApplication {
                                                                                   function: Variable {
                                                                                    identifier: "optionalString",
                                                                                    position: (530, 11),
                                                                                   },
                                                                                   arguments: [
                                                                                    PropertyAccess {
                                                                                     expression: Variable {
                                                                                      identifier: "cfg",
                                                                                      position: (530, 26),
                                                                                     },
                                                                                     attribute_path: AttributePath {
                                                                                      attributes: [
                                                                                       Raw {
                                                                                        content: "otpwAuth",
                                                                                        position: (530, 30),
                                                                                       },
                                                                                      ],
                                                                                     },
                                                                                     default: None,
                                                                                    },
                                                                                    String {
                                                                                     parts: [
                                                                                      Raw {
                                                                                       content: "auth sufficient ",
                                                                                       position: (531, 1),
                                                                                      },
                                                                                      Expression {
                                                                                       expression: PropertyAccess {
                                                                                        expression: Variable {
                                                                                         identifier: "pkgs",
                                                                                         position: (531, 31),
                                                                                        },
                                                                                        attribute_path: AttributePath {
                                                                                         attributes: [
                                                                                          Raw {
                                                                                           content: "otpw",
                                                                                           position: (531, 36),
                                                                                          },
                                                                                         ],
                                                                                        },
                                                                                        default: None,
                                                                                       },
                                                                                      },
                                                                                      Raw {
                                                                                       content: "/lib/security/pam_otpw.so\n",
                                                                                       position: (531, 41),
                                                                                      },
                                                                                     ],
                                                                                    },
                                                                                   ],
                                                                                  },
                                                                                 ],
                                                                                 position: (529, 14),
                                                                                },
                                                                                FunctionApplication {
                                                                                 function: Variable {
                                                                                  identifier: "optionalString",
                                                                                  position: (533, 11),
                                                                                 },
                                                                                 arguments: [
                                                                                  Variable {
                                                                                   identifier: "use_ldap",
                                                                                   position: (533, 26),
                                                                                  },
                                                                                  String {
                                                                                   parts: [
                                                                                    Raw {
                                                                                     content: "auth sufficient ",
                                                                                     position: (534, 1),
                                                                                    },
                                                                                    Expression {
                                                                                     expression: Variable {
                                                                                      identifier: "pam_ldap",
                                                                                      position: (534, 31),
                                                                                     },
                                                                                    },
                                                                                    Raw {
                                                                                     content: "/lib/security/pam_ldap.so use_first_pass\n",
                                                                                     position: (534, 40),
                                                                                    },
                                                                                   ],
                                                                                  },
                                                                                 ],
                                                                                },
                                                                               ],
                                                                               position: (532, 14),
                                                                              },
                                                                              FunctionApplication {
                                                                               function: Variable {
                                                                                identifier: "optionalString",
                                                                                position: (536, 11),
                                                                               },
                                                                               arguments: [
                                                                                PropertyAccess {
                                                                                 expression: Variable {
                                                                                  identifier: "config",
                                                                                  position: (536, 26),
                                                                                 },
                                                                                 attribute_path: AttributePath {
                                                                                  attributes: [
                                                                                   Raw {
                                                                                    content: "services",
                                                                                    position: (536, 33),
                                                                                   },
                                                                                   Raw {
                                                                                    content: "sssd",
                                                                                    position: (536, 42),
                                                                                   },
                                                                                   Raw {
                                                                                    content: "enable",
                                                                                    position: (536, 47),
                                                                                   },
                                                                                  ],
                                                                                 },
                                                                                 default: None,
                                                                                },
                                                                                String {
                                                                                 parts: [
                                                                                  Raw {
                                                                                   content: "auth sufficient ",
                                                                                   position: (537, 1),
                                                                                  },
                                                                                  Expression {
                                                                                   expression: PropertyAccess {
                                                                                    expression: Variable {
                                                                                     identifier: "pkgs",
                                                                                     position: (537, 31),
                                                                                    },
                                                                                    attribute_path: AttributePath {
                                                                                     attributes: [
                                                                                      Raw {
                                                                                       content: "sssd",
                                                                                       position: (537, 36),
                                                                                      },
                                                                                     ],
                                                                                    },
                                                                                    default: None,
                                                                                   },
                                                                                  },
                                                                                  Raw {
                                                                                   content: "/lib/security/pam_sss.so use_first_pass\n",
                                                                                   position: (537, 41),
                                                                                  },
                                                                                 ],
                                                                                },
                                                                               ],
                                                                              },
                                                                             ],
                                                                             position: (535, 14),
                                                                            },
                                                                            FunctionApplication {
                                                                             function: Variable {
                                                                              identifier: "optionalString",
                                                                              position: (539, 11),
                                                                             },
                                                                             arguments: [
                                                                              PropertyAccess {
                                                                               expression: Variable {
                                                                                identifier: "config",
                                                                                position: (539, 26),
                                                                               },
                                                                               attribute_path: AttributePath {
                                                                                attributes: [
                                                                                 Raw {
                                                                                  content: "krb5",
                                                                                  position: (539, 33),
                                                                                 },
                                                                                 Raw {
                                                                                  content: "enable",
                                                                                  position: (539, 38),
                                                                                 },
                                                                                ],
                                                                               },
                                                                               default: None,
                                                                              },
                                                                              String {
                                                                               parts: [
                                                                                Raw {
                                                                                 content: "auth [default=ignore success=1 service_err=reset] ",
                                                                                 position: (540, 1),
                                                                                },
                                                                                Expression {
                                                                                 expression: Variable {
                                                                                  identifier: "pam_krb5",
                                                                                  position: (540, 65),
                                                                                 },
                                                                                },
                                                                                Raw {
                                                                                 content: "/lib/security/pam_krb5.so use_first_pass\nauth [default=die success=done] ",
                                                                                 position: (540, 74),
                                                                                },
                                                                                Expression {
                                                                                 expression: Variable {
                                                                                  identifier: "pam_ccreds",
                                                                                  position: (541, 47),
                                                                                 },
                                                                                },
                                                                                Raw {
                                                                                 content: "/lib/security/pam_ccreds.so action=validate use_first_pass\nauth sufficient ",
                                                                                 position: (541, 58),
                                                                                },
                                                                                Expression {
                                                                                 expression: Variable {
                                                                                  identifier: "pam_ccreds",
                                                                                  position: (542, 31),
                                                                                 },
                                                                                },
                                                                                Raw {
                                                                                 content: "/lib/security/pam_ccreds.so action=store use_first_pass\n",
                                                                                 position: (542, 42),
                                                                                },
                                                                               ],
                                                                              },
                                                                             ],
                                                                            },
                                                                           ],
                                                                           position: (538, 14),
                                                                          },
                                                                          String {
                                                                           parts: [
                                                                            Raw {
                                                                             content: "auth required pam_deny.so\n\n# Password management.\npassword sufficient pam_unix.so nullok sha512\n",
                                                                             position: (545, 1),
                                                                            },
                                                                           ],
                                                                          },
                                                                         ],
                                                                         position: (543, 14),
                                                                        },
                                                                        FunctionApplication {
                                                                         function: Variable {
                                                                          identifier: "optionalString",
                                                                          position: (550, 11),
                                                                         },
                                                                         arguments: [
                                                                          PropertyAccess {
                                                                           expression: Variable {
                                                                            identifier: "config",
                                                                            position: (550, 26),
                                                                           },
                                                                           attribute_path: AttributePath {
                                                                            attributes: [
                                                                             Raw {
                                                                              content: "security",
                                                                              position: (550, 33),
                                                                             },
                                                                             Raw {
                                                                              content: "pam",
                                                                              position: (550, 42),
                                                                             },
                                                                             Raw {
                                                                              content: "enableEcryptfs",
                                                                              position: (550, 46),
                                                                             },
                                                                            ],
                                                                           },
                                                                           default: None,
                                                                          },
                                                                          String {
                                                                           parts: [
                                                                            Raw {
                                                                             content: "password optional ",
                                                                             position: (551, 1),
                                                                            },
                                                                            Expression {
                                                                             expression: PropertyAccess {
                                                                              expression: Variable {
                                                                               identifier: "pkgs",
                                                                               position: (551, 33),
                                                                              },
                                                                              attribute_path: AttributePath {
                                                                               attributes: [
                                                                                Raw {
                                                                                 content: "ecryptfs",
                                                                                 position: (551, 38),
                                                                                },
                                                                               ],
                                                                              },
                                                                              default: None,
                                                                             },
                                                                            },
                                                                            Raw {
                                                                             content: "/lib/security/pam_ecryptfs.so\n",
                                                                             position: (551, 47),
                                                                            },
                                                                           ],
                                                                          },
                                                                         ],
                                                                        },
                                                                       ],
                                                                       position: (549, 14),
                                                                      },
                                                                      FunctionApplication {
                                                                       function: Variable {
                                                                        identifier: "optionalString",
                                                                        position: (553, 11),
                                                                       },
                                                                       arguments: [
                                                                        PropertyAccess {
                                                                         expression: Variable {
                                                                          identifier: "cfg",
                                                                          position: (553, 26),
                                                                         },
                                                                         attribute_path: AttributePath {
                                                                          attributes: [
                                                                           Raw {
                                                                            content: "pamMount",
                                                                            position: (553, 30),
                                                                           },
                                                                          ],
                                                                         },
                                                                         default: None,
                                                                        },
                                                                        String {
                                                                         parts: [
                                                                          Raw {
                                                                           content: "password optional ",
                                                                           position: (554, 1),
                                                                          },
                                                                          Expression {
                                                                           expression: PropertyAccess {
                                                                            expression: Variable {
                                                                             identifier: "pkgs",
                                                                             position: (554, 33),
                                                                            },
                                                                            attribute_path: AttributePath {
                                                                             attributes: [
                                                                              Raw {
                                                                               content: "pam_mount",
                                                                               position: (554, 38),
                                                                              },
                                                                             ],
                                                                            },
                                                                            default: None,
                                                                           },
                                                                          },
                                                                          Raw {
                                                                           content: "/lib/security/pam_mount.so\n",
                                                                           position: (554, 48),
                                                                          },
                                                                         ],
                                                                        },
                                                                       ],
                                                                      },
                                                                     ],
                                                                     position: (552, 14),
                                                                    },
                                                                    FunctionApplication {
                                                                     function: Variable {
                                                                      identifier: "optionalString",
                                                                      position: (556, 11),
                                                                     },
                                                                     arguments: [
                                                                      Variable {
                                                                       identifier: "use_ldap",
                                                                       position: (556, 26),
                                                                      },
                                                                      String {
                                                                       parts: [
                                                                        Raw {
                                                                         content: "password sufficient ",
                                                                         position: (557, 1),
                                                                        },
                                                                        Expression {
                                                                         expression: Variable {
                                                                          identifier: "pam_ldap",
                                                                          position: (557, 35),
                                                                         },
                                                                        },
                                                                        Raw {
                                                                         content: "/lib/security/pam_ldap.so\n",
                                                                         position: (557, 44),
                                                                        },
                                                                       ],
                                                                      },
                                                                     ],
                                                                    },
                                                                   ],
                                                                   position: (555, 14),
                                                                  },
                                                                  FunctionApplication {
                                                                   function: Variable {
                                                                    identifier: "optionalString",
                                                                    position: (559, 11),
                                                                   },
                                                                   arguments: [
                                                                    PropertyAccess {
                                                                     expression: Variable {
                                                                      identifier: "config",
                                                                      position: (559, 26),
                                                                     },
                                                                     attribute_path: AttributePath {
                                                                      attributes: [
                                                                       Raw {
                                                                        content: "services",
                                                                        position: (559, 33),
                                                                       },
                                                                       Raw {
                                                                        content: "sssd",
                                                                        position: (559, 42),
                                                                       },
                                                                       Raw {
                                                                        content: "enable",
                                                                        position: (559, 47),
                                                                       },
                                                                      ],
                                                                     },
                                                                     default: None,
                                                                    },
                                                                    String {
                                                                     parts: [
                                                                      Raw {
                                                                       content: "password sufficient ",
                                                                       position: (560, 1),
                                                                      },
                                                                      Expression {
                                                                       expression: PropertyAccess {
                                                                        expression: Variable {
                                                                         identifier: "pkgs",
                                                                         position: (560, 35),
                                                                        },
                                                                        attribute_path: AttributePath {
                                                                         attributes: [
                                                                          Raw {
                                                                           content: "sssd",
                                                                           position: (560, 40),
                                                                          },
                                                                         ],
                                                                        },
                                                                        default: None,
                                                                       },
                                                                      },
                                                                      Raw {
                                                                       content: "/lib/security/pam_sss.so use_authtok\n",
                                                                       position: (560, 45),
                                                                      },
                                                                     ],
                                                                    },
                                                                   ],
                                                                  },
                                                                 ],
                                                                 position: (558, 14),
                                                                },
                                                                FunctionApplication {
                                                                 function: Variable {
                                                                  identifier: "optionalString",
                                                                  position: (562, 11),
                                                                 },
                                                                 arguments: [
                                                                  PropertyAccess {
                                                                   expression: Variable {
                                                                    identifier: "config",
                                                                    position: (562, 26),
                                                                   },
                                                                   attribute_path: AttributePath {
                                                                    attributes: [
                                                                     Raw {
                                                                      content: "krb5",
                                                                      position: (562, 33),
                                                                     },
                                                                     Raw {
                                                                      content: "enable",
                                                                      position: (562, 38),
                                                                     },
                                                                    ],
                                                                   },
                                                                   default: None,
                                                                  },
                                                                  String {
                                                                   parts: [
                                                                    Raw {
                                                                     content: "password sufficient ",
                                                                     position: (563, 1),
                                                                    },
                                                                    Expression {
                                                                     expression: Variable {
                                                                      identifier: "pam_krb5",
                                                                      position: (563, 35),
                                                                     },
                                                                    },
                                                                    Raw {
                                                                     content: "/lib/security/pam_krb5.so use_first_pass\n",
                                                                     position: (563, 44),
                                                                    },
                                                                   ],
                                                                  },
                                                                 ],
                                                                },
                                                               ],
                                                               position: (561, 14),
                                                              },
                                                              FunctionApplication {
                                                               function: Variable {
                                                                identifier: "optionalString",
                                                                position: (565, 11),
                                                               },
                                                               arguments: [
                                                                PropertyAccess {
                                                                 expression: Variable {
                                                                  identifier: "cfg",
                                                                  position: (565, 26),
                                                                 },
                                                                 attribute_path: AttributePath {
                                                                  attributes: [
                                                                   Raw {
                                                                    content: "enableGnomeKeyring",
                                                                    position: (565, 30),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                                String {
                                                                 parts: [
                                                                  Raw {
                                                                   content: "password optional ",
                                                                   position: (566, 1),
                                                                  },
                                                                  Expression {
                                                                   expression: PropertyAccess {
                                                                    expression: Variable {
                                                                     identifier: "pkgs",
                                                                     position: (566, 33),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                     attributes: [
                                                                      Raw {
                                                                       content: "gnome",
                                                                       position: (566, 38),
                                                                      },
                                                                      Raw {
                                                                       content: "gnome-keyring",
                                                                       position: (566, 44),
                                                                      },
                                                                     ],
                                                                    },
                                                                    default: None,
                                                                   },
                                                                  },
                                                                  Raw {
                                                                   content: "/lib/security/pam_gnome_keyring.so use_authtok\n",
                                                                   position: (566, 58),
                                                                  },
                                                                 ],
                                                                },
                                                               ],
                                                              },
                                                             ],
                                                             position: (564, 14),
                                                            },
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "\n# Session management.\n",
                                                               position: (569, 1),
                                                              },
                                                             ],
                                                            },
                                                           ],
                                                           position: (567, 14),
                                                          },
                                                          FunctionApplication {
                                                           function: Variable {
                                                            identifier: "optionalString",
                                                            position: (572, 11),
                                                           },
                                                           arguments: [
                                                            PropertyAccess {
                                                             expression: Variable {
                                                              identifier: "cfg",
                                                              position: (572, 26),
                                                             },
                                                             attribute_path: AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "setEnvironment",
                                                                position: (572, 30),
                                                               },
                                                              ],
                                                             },
                                                             default: None,
                                                            },
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "session required pam_env.so conffile=/etc/pam/environment readenv=0\n",
                                                               position: (573, 1),
                                                              },
                                                             ],
                                                            },
                                                           ],
                                                          },
                                                         ],
                                                         position: (571, 14),
                                                        },
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "session required pam_unix.so\n",
                                                           position: (576, 1),
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                       position: (574, 14),
                                                      },
                                                      FunctionApplication {
                                                       function: Variable {
                                                        identifier: "optionalString",
                                                        position: (578, 11),
                                                       },
                                                       arguments: [
                                                        PropertyAccess {
                                                         expression: Variable {
                                                          identifier: "cfg",
                                                          position: (578, 26),
                                                         },
                                                         attribute_path: AttributePath {
                                                          attributes: [
                                                           Raw {
                                                            content: "setLoginUid",
                                                            position: (578, 30),
                                                           },
                                                          ],
                                                         },
                                                         default: None,
                                                        },
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "session ",
                                                           position: (579, 1),
                                                          },
                                                          Expression {
                                                           expression: IfThenElse {
                                                            predicate: PropertyAccess {
                                                             expression: Variable {
                                                              identifier: "config",
                                                              position: (579, 26),
                                                             },
                                                             attribute_path: AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "boot",
                                                                position: (579, 33),
                                                               },
                                                               Raw {
                                                                content: "isContainer",
                                                                position: (579, 38),
                                                               },
                                                              ],
                                                             },
                                                             default: None,
                                                            },
                                                            then: String {
                                                             parts: [
                                                              Raw {
                                                               content: "optional",
                                                               position: (579, 56),
                                                              },
                                                             ],
                                                            },
                                                            else_: String {
                                                             parts: [
                                                              Raw {
                                                               content: "required",
                                                               position: (579, 72),
                                                              },
                                                             ],
                                                            },
                                                            position: (579, 23),
                                                           },
                                                          },
                                                          Raw {
                                                           content: " pam_loginuid.so\n",
                                                           position: (579, 82),
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                     position: (577, 14),
                                                    },
                                                    FunctionApplication {
                                                     function: Variable {
                                                      identifier: "optionalString",
                                                      position: (581, 11),
                                                     },
                                                     arguments: [
                                                      PropertyAccess {
                                                       expression: Variable {
                                                        identifier: "cfg",
                                                        position: (581, 26),
                                                       },
                                                       attribute_path: AttributePath {
                                                        attributes: [
                                                         Raw {
                                                          content: "ttyAudit",
                                                          position: (581, 30),
                                                         },
                                                         Raw {
                                                          content: "enable",
                                                          position: (581, 39),
                                                         },
                                                        ],
                                                       },
                                                       default: None,
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "session required ",
                                                         position: (582, 1),
                                                        },
                                                        Expression {
                                                         expression: PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "pkgs",
                                                           position: (582, 32),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "pam",
                                                             position: (582, 37),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                        },
                                                        Raw {
                                                         content: "/lib/security/pam_tty_audit.so\n    open_only=",
                                                         position: (582, 41),
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "toString",
                                                           position: (583, 29),
                                                          },
                                                          arguments: [
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "cfg",
                                                             position: (583, 38),
                                                            },
                                                            attribute_path: AttributePath {
                                                             attributes: [
                                                              Raw {
                                                               content: "ttyAudit",
                                                               position: (583, 42),
                                                              },
                                                              Raw {
                                                               content: "openOnly",
                                                               position: (583, 51),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "\n    ",
                                                         position: (583, 60),
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "optionalString",
                                                           position: (584, 19),
                                                          },
                                                          arguments: [
                                                           BinaryOperation {
                                                            operator: NotEqualTo,
                                                            operands: [
                                                             PropertyAccess {
                                                              expression: Variable {
                                                               identifier: "cfg",
                                                               position: (584, 35),
                                                              },
                                                              attribute_path: AttributePath {
                                                               attributes: [
                                                                Raw {
                                                                 content: "ttyAudit",
                                                                 position: (584, 39),
                                                                },
                                                                Raw {
                                                                 content: "enablePattern",
                                                                 position: (584, 48),
                                                                },
                                                               ],
                                                              },
                                                              default: None,
                                                             },
                                                             Variable {
                                                              identifier: "null",
                                                              position: (584, 65),
                                                             },
                                                            ],
                                                            position: (584, 62),
                                                           },
                                                           String {
                                                            parts: [
                                                             Raw {
                                                              content: "enable=",
                                                              position: (584, 72),
                                                             },
                                                             Expression {
                                                              expression: PropertyAccess {
                                                               expression: Variable {
                                                                identifier: "cfg",
                                                                position: (584, 81),
                                                               },
                                                               attribute_path: AttributePath {
                                                                attributes: [
                                                                 Raw {
                                                                  content: "ttyAudit",
                                                                  position: (584, 85),
                                                                 },
                                                                 Raw {
                                                                  content: "enablePattern",
                                                                  position: (584, 94),
                                                                 },
                                                                ],
                                                               },
                                                               default: None,
                                                              },
                                                             },
                                                            ],
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "\n    ",
                                                         position: (584, 110),
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "optionalString",
                                                           position: (585, 19),
                                                          },
                                                          arguments: [
                                                           BinaryOperation {
                                                            operator: NotEqualTo,
                                                            operands: [
                                                             PropertyAccess {
                                                              expression: Variable {
                                                               identifier: "cfg",
                                                               position: (585, 35),
                                                              },
                                                              attribute_path: AttributePath {
                                                               attributes: [
                                                                Raw {
                                                                 content: "ttyAudit",
                                                                 position: (585, 39),
                                                                },
                                                                Raw {
                                                                 content: "disablePattern",
                                                                 position: (585, 48),
                                                                },
                                                               ],
                                                              },
                                                              default: None,
                                                             },
                                                             Variable {
                                                              identifier: "null",
                                                              position: (585, 66),
                                                             },
                                                            ],
                                                            position: (585, 63),
                                                           },
                                                           String {
                                                            parts: [
                                                             Raw {
                                                              content: "disable=",
                                                              position: (585, 73),
                                                             },
                                                             Expression {
                                                              expression: PropertyAccess {
                                                               expression: Variable {
                                                                identifier: "cfg",
                                                                position: (585, 83),
                                                               },
                                                               attribute_path: AttributePath {
                                                                attributes: [
                                                                 Raw {
                                                                  content: "ttyAudit",
                                                                  position: (585, 87),
                                                                 },
                                                                 Raw {
                                                                  content: "disablePattern",
                                                                  position: (585, 96),
                                                                 },
                                                                ],
                                                               },
                                                               default: None,
                                                              },
                                                             },
                                                            ],
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "\n",
                                                         position: (585, 113),
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                   position: (580, 14),
                                                  },
                                                  FunctionApplication {
                                                   function: Variable {
                                                    identifier: "optionalString",
                                                    position: (587, 11),
                                                   },
                                                   arguments: [
                                                    PropertyAccess {
                                                     expression: Variable {
                                                      identifier: "cfg",
                                                      position: (587, 26),
                                                     },
                                                     attribute_path: AttributePath {
                                                      attributes: [
                                                       Raw {
                                                        content: "makeHomeDir",
                                                        position: (587, 30),
                                                       },
                                                      ],
                                                     },
                                                     default: None,
                                                    },
                                                    String {
                                                     parts: [
                                                      Raw {
                                                       content: "session required ",
                                                       position: (588, 1),
                                                      },
                                                      Expression {
                                                       expression: PropertyAccess {
                                                        expression: Variable {
                                                         identifier: "pkgs",
                                                         position: (588, 32),
                                                        },
                                                        attribute_path: AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "pam",
                                                           position: (588, 37),
                                                          },
                                                         ],
                                                        },
                                                        default: None,
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/pam_mkhomedir.so silent skel=",
                                                       position: (588, 41),
                                                      },
                                                      Expression {
                                                       expression: PropertyAccess {
                                                        expression: Variable {
                                                         identifier: "config",
                                                         position: (588, 86),
                                                        },
                                                        attribute_path: AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "security",
                                                           position: (588, 93),
                                                          },
                                                          Raw {
                                                           content: "pam",
                                                           position: (588, 102),
                                                          },
                                                          Raw {
                                                           content: "makeHomeDir",
                                                           position: (588, 106),
                                                          },
                                                          Raw {
                                                           content: "skelDirectory",
                                                           position: (588, 118),
                                                          },
                                                         ],
                                                        },
                                                        default: None,
                                                       },
                                                      },
                                                      Raw {
                                                       content: " umask=0077\n",
                                                       position: (588, 132),
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                 position: (586, 14),
                                                },
                                                FunctionApplication {
                                                 function: Variable {
                                                  identifier: "optionalString",
                                                  position: (590, 11),
                                                 },
                                                 arguments: [
                                                  PropertyAccess {
                                                   expression: Variable {
                                                    identifier: "cfg",
                                                    position: (590, 26),
                                                   },
                                                   attribute_path: AttributePath {
                                                    attributes: [
                                                     Raw {
                                                      content: "updateWtmp",
                                                      position: (590, 30),
                                                     },
                                                    ],
                                                   },
                                                   default: None,
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "session required ",
                                                     position: (591, 1),
                                                    },
                                                    Expression {
                                                     expression: PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "pkgs",
                                                       position: (591, 32),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "pam",
                                                         position: (591, 37),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    },
                                                    Raw {
                                                     content: "/lib/security/pam_lastlog.so silent\n",
                                                     position: (591, 41),
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                },
                                               ],
                                               position: (589, 14),
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "optionalString",
                                                position: (593, 11),
                                               },
                                               arguments: [
                                                PropertyAccess {
                                                 expression: Variable {
                                                  identifier: "config",
                                                  position: (593, 26),
                                                 },
                                                 attribute_path: AttributePath {
                                                  attributes: [
                                                   Raw {
                                                    content: "security",
                                                    position: (593, 33),
                                                   },
                                                   Raw {
                                                    content: "pam",
                                                    position: (593, 42),
                                                   },
                                                   Raw {
                                                    content: "enableEcryptfs",
                                                    position: (593, 46),
                                                   },
                                                  ],
                                                 },
                                                 default: None,
                                                },
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "session optional ",
                                                   position: (594, 1),
                                                  },
                                                  Expression {
                                                   expression: PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "pkgs",
                                                     position: (594, 32),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "ecryptfs",
                                                       position: (594, 37),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                  },
                                                  Raw {
                                                   content: "/lib/security/pam_ecryptfs.so\n",
                                                   position: (594, 46),
                                                  },
                                                 ],
                                                },
                                               ],
                                              },
                                             ],
                                             position: (592, 14),
                                            },
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "optionalString",
                                              position: (596, 11),
                                             },
                                             arguments: [
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "cfg",
                                                position: (596, 26),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "pamMount",
                                                  position: (596, 30),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "session optional ",
                                                 position: (597, 1),
                                                },
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "pkgs",
                                                   position: (597, 32),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "pam_mount",
                                                     position: (597, 37),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: "/lib/security/pam_mount.so disable_interactive\n",
                                                 position: (597, 47),
                                                },
                                               ],
                                              },
                                             ],
                                            },
                                           ],
                                           position: (595, 14),
                                          },
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "optionalString",
                                            position: (599, 11),
                                           },
                                           arguments: [
                                            Variable {
                                             identifier: "use_ldap",
                                             position: (599, 26),
                                            },
                                            String {
                                             parts: [
                                              Raw {
                                               content: "session optional ",
                                               position: (600, 1),
                                              },
                                              Expression {
                                               expression: Variable {
                                                identifier: "pam_ldap",
                                                position: (600, 32),
                                               },
                                              },
                                              Raw {
                                               content: "/lib/security/pam_ldap.so\n",
                                               position: (600, 41),
                                              },
                                             ],
                                            },
                                           ],
                                          },
                                         ],
                                         position: (598, 14),
                                        },
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "optionalString",
                                          position: (602, 11),
                                         },
                                         arguments: [
                                          PropertyAccess {
                                           expression: Variable {
                                            identifier: "config",
                                            position: (602, 26),
                                           },
                                           attribute_path: AttributePath {
                                            attributes: [
                                             Raw {
                                              content: "services",
                                              position: (602, 33),
                                             },
                                             Raw {
                                              content: "sssd",
                                              position: (602, 42),
                                             },
                                             Raw {
                                              content: "enable",
                                              position: (602, 47),
                                             },
                                            ],
                                           },
                                           default: None,
                                          },
                                          String {
                                           parts: [
                                            Raw {
                                             content: "session optional ",
                                             position: (603, 1),
                                            },
                                            Expression {
                                             expression: PropertyAccess {
                                              expression: Variable {
                                               identifier: "pkgs",
                                               position: (603, 32),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "sssd",
                                                 position: (603, 37),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                            },
                                            Raw {
                                             content: "/lib/security/pam_sss.so\n",
                                             position: (603, 42),
                                            },
                                           ],
                                          },
                                         ],
                                        },
                                       ],
                                       position: (601, 14),
                                      },
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "optionalString",
                                        position: (605, 11),
                                       },
                                       arguments: [
                                        PropertyAccess {
                                         expression: Variable {
                                          identifier: "config",
                                          position: (605, 26),
                                         },
                                         attribute_path: AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "krb5",
                                            position: (605, 33),
                                           },
                                           Raw {
                                            content: "enable",
                                            position: (605, 38),
                                           },
                                          ],
                                         },
                                         default: None,
                                        },
                                        String {
                                         parts: [
                                          Raw {
                                           content: "session optional ",
                                           position: (606, 1),
                                          },
                                          Expression {
                                           expression: Variable {
                                            identifier: "pam_krb5",
                                            position: (606, 32),
                                           },
                                          },
                                          Raw {
                                           content: "/lib/security/pam_krb5.so\n",
                                           position: (606, 41),
                                          },
                                         ],
                                        },
                                       ],
                                      },
                                     ],
                                     position: (604, 14),
                                    },
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "optionalString",
                                      position: (608, 11),
                                     },
                                     arguments: [
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (608, 26),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "otpwAuth",
                                          position: (608, 30),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "session optional ",
                                         position: (609, 1),
                                        },
                                        Expression {
                                         expression: PropertyAccess {
                                          expression: Variable {
                                           identifier: "pkgs",
                                           position: (609, 32),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "otpw",
                                             position: (609, 37),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                        },
                                        Raw {
                                         content: "/lib/security/pam_otpw.so\n",
                                         position: (609, 42),
                                        },
                                       ],
                                      },
                                     ],
                                    },
                                   ],
                                   position: (607, 14),
                                  },
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "optionalString",
                                    position: (611, 11),
                                   },
                                   arguments: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (611, 26),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "startSession",
                                        position: (611, 30),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "session optional ",
                                       position: (612, 1),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (612, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "systemd",
                                           position: (612, 37),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/lib/security/pam_systemd.so\n",
                                       position: (612, 45),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 ],
                                 position: (610, 14),
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "optionalString",
                                  position: (614, 11),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (614, 26),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "forwardXAuth",
                                      position: (614, 30),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "session optional pam_xauth.so xauthpath=",
                                     position: (615, 1),
                                    },
                                    Expression {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "pkgs",
                                       position: (615, 55),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "xorg",
                                         position: (615, 60),
                                        },
                                        Raw {
                                         content: "xauth",
                                         position: (615, 65),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                    Raw {
                                     content: "/bin/xauth systemuser=99\n",
                                     position: (615, 71),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ],
                               position: (613, 14),
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "optionalString",
                                position: (617, 11),
                               },
                               arguments: [
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (617, 27),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "limits",
                                      position: (617, 31),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  List {
                                   elements: [],
                                   position: (617, 41),
                                  },
                                 ],
                                 position: (617, 38),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "session required ",
                                   position: (618, 1),
                                  },
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (618, 32),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "pam",
                                       position: (618, 37),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/lib/security/pam_limits.so conf=",
                                   position: (618, 41),
                                  },
                                  Expression {
                                   expression: FunctionApplication {
                                    function: Variable {
                                     identifier: "makeLimitsConf",
                                     position: (618, 76),
                                    },
                                    arguments: [
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "cfg",
                                       position: (618, 91),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "limits",
                                         position: (618, 95),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    ],
                                   },
                                  },
                                  Raw {
                                   content: "\n",
                                   position: (618, 102),
                                  },
                                 ],
                                },
                               ],
                              },
                             ],
                             position: (616, 14),
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "optionalString",
                              position: (620, 11),
                             },
                             arguments: [
                              BinaryOperation {
                               operator: LogicalAnd,
                               operands: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (620, 27),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "showMotd",
                                    position: (620, 31),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "config",
                                    position: (620, 43),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "users",
                                      position: (620, 50),
                                     },
                                     Raw {
                                      content: "motd",
                                      position: (620, 56),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (620, 64),
                                  },
                                 ],
                                 position: (620, 61),
                                },
                               ],
                               position: (620, 40),
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "session optional ",
                                 position: (621, 1),
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (621, 32),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "pam",
                                     position: (621, 37),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/lib/security/pam_motd.so motd=",
                                 position: (621, 41),
                                },
                                Expression {
                                 expression: Variable {
                                  identifier: "motd",
                                  position: (621, 74),
                                 },
                                },
                                Raw {
                                 content: "\n",
                                 position: (621, 79),
                                },
                               ],
                              },
                             ],
                            },
                           ],
                           position: (619, 14),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "optionalString",
                            position: (623, 11),
                           },
                           arguments: [
                            BinaryOperation {
                             operator: LogicalAnd,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (623, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "enableAppArmor",
                                  position: (623, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "config",
                                position: (623, 49),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "security",
                                  position: (623, 56),
                                 },
                                 Raw {
                                  content: "apparmor",
                                  position: (623, 65),
                                 },
                                 Raw {
                                  content: "enable",
                                  position: (623, 74),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                             position: (623, 46),
                            },
                            String {
                             parts: [
                              Raw {
                               content: "session optional ",
                               position: (624, 1),
                              },
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (624, 32),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "apparmor-pam",
                                   position: (624, 37),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: "/lib/security/pam_apparmor.so order=user,group,default debug\n",
                               position: (624, 50),
                              },
                             ],
                            },
                           ],
                          },
                         ],
                         position: (622, 14),
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "optionalString",
                          position: (626, 11),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (626, 27),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "enableKwallet",
                              position: (626, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [
                            Raw {
                             content: "session optional ",
                             position: (627, 1),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (627, 32),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "plasma5Packages",
                                 position: (627, 37),
                                },
                                Raw {
                                 content: "kwallet-pam",
                                 position: (627, 53),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/lib/security/pam_kwallet5.so kwalletd=",
                             position: (627, 65),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (627, 106),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "plasma5Packages",
                                 position: (627, 111),
                                },
                                Raw {
                                 content: "kwallet",
                                 position: (627, 127),
                                },
                                Raw {
                                 content: "bin",
                                 position: (627, 135),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/bin/kwalletd5\n",
                             position: (627, 139),
                            },
                           ],
                          },
                         ],
                        },
                       ],
                       position: (625, 14),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (629, 11),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (629, 27),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "enableGnomeKeyring",
                            position: (629, 31),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "session optional ",
                           position: (630, 1),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (630, 32),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "gnome",
                               position: (630, 37),
                              },
                              Raw {
                               content: "gnome-keyring",
                               position: (630, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/lib/security/pam_gnome_keyring.so auto_start\n",
                           position: (630, 57),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                     position: (628, 14),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (632, 11),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (632, 26),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "gnupg",
                          position: (632, 30),
                         },
                         Raw {
                          content: "enable",
                          position: (632, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "session optional ",
                         position: (633, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (633, 32),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "pam_gnupg",
                             position: (633, 37),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/lib/security/pam_gnupg.so ",
                         position: (633, 47),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "optionalString",
                           position: (633, 76),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (633, 91),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "gnupg",
                               position: (633, 95),
                              },
                              Raw {
                               content: "noAutostart",
                               position: (633, 101),
                              },
                             ],
                            },
                            default: None,
                           },
                           String {
                            parts: [
                             Raw {
                              content: " no-autostart",
                              position: (633, 114),
                             },
                            ],
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                         position: (633, 129),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                   position: (631, 14),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optionalString",
                    position: (635, 11),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (635, 27),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "virtualisation",
                        position: (635, 34),
                       },
                       Raw {
                        content: "lxc",
                        position: (635, 49),
                       },
                       Raw {
                        content: "lxcfs",
                        position: (635, 53),
                       },
                       Raw {
                        content: "enable",
                        position: (635, 59),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "session optional ",
                       position: (636, 1),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (636, 32),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "lxc",
                           position: (636, 37),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/lib/security/pam_cgfs.so -c all\n",
                       position: (636, 41),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (634, 14),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (420, 14),
           },
          ),
         ],
         recursive: false,
         position: (11, 87),
        },
        position: (11, 57),
       },
       position: (11, 36),
      },
      position: (11, 13),
     },
    ),
    Inherit(
     Some(
      Variable {
       identifier: "pkgs",
       position: (644, 12),
      },
     ),
     [
      Raw {
       content: "pam_krb5",
       position: (644, 18),
      },
      Raw {
       content: "pam_ccreds",
       position: (644, 27),
      },
     ],
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "use_ldap",
        position: (646, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (646, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "users",
           position: (646, 22),
          },
          Raw {
           content: "ldap",
           position: (646, 28),
          },
          Raw {
           content: "enable",
           position: (646, 33),
          },
         ],
        },
        default: None,
       },
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (646, 43),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "users",
           position: (646, 50),
          },
          Raw {
           content: "ldap",
           position: (646, 56),
          },
          Raw {
           content: "loginPam",
           position: (646, 61),
          },
         ],
        },
        default: None,
       },
      ],
      position: (646, 40),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pam_ldap",
        position: (647, 3),
       },
      ],
     },
     IfThenElse {
      predicate: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (647, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "users",
          position: (647, 24),
         },
         Raw {
          content: "ldap",
          position: (647, 30),
         },
         Raw {
          content: "daemon",
          position: (647, 35),
         },
         Raw {
          content: "enable",
          position: (647, 42),
         },
        ],
       },
       default: None,
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (647, 54),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "nss_pam_ldapd",
          position: (647, 59),
         },
        ],
       },
       default: None,
      },
      else_: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (647, 78),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "pam_ldap",
          position: (647, 83),
         },
        ],
       },
       default: None,
      },
      position: (647, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeLimitsConf",
        position: (650, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "limits",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (651, 5),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeText",
           position: (651, 10),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "limits.conf",
           position: (651, 21),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "concatMapStrings",
          position: (652, 9),
         },
         arguments: [
          Function {
           argument: None,
           arguments: FunctionArguments {
            arguments: [
             FunctionArgument {
              identifier: "value",
              default: None,
             },
             FunctionArgument {
              identifier: "item",
              default: None,
             },
             FunctionArgument {
              identifier: "type",
              default: None,
             },
             FunctionArgument {
              identifier: "domain",
              default: None,
             },
            ],
            ellipsis: false,
           },
           definition: String {
            parts: [
             Expression {
              expression: Variable {
               identifier: "domain",
               position: (653, 13),
              },
             },
             Raw {
              content: " ",
              position: (653, 20),
             },
             Expression {
              expression: Variable {
               identifier: "type",
               position: (653, 23),
              },
             },
             Raw {
              content: " ",
              position: (653, 28),
             },
             Expression {
              expression: Variable {
               identifier: "item",
               position: (653, 31),
              },
             },
             Raw {
              content: " ",
              position: (653, 36),
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (653, 39),
               },
               arguments: [
                Variable {
                 identifier: "value",
                 position: (653, 48),
                },
               ],
              },
             },
             Raw {
              content: "\n",
              position: (653, 54),
             },
            ],
           },
           position: (652, 27),
          },
          Variable {
           identifier: "limits",
           position: (654, 10),
          },
         ],
        },
       ],
      },
      position: (650, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "limitsType",
        position: (656, 3),
       },
      ],
     },
     With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (656, 21),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "types",
          position: (656, 25),
         },
        ],
       },
       default: None,
      },
      target: FunctionApplication {
       function: Variable {
        identifier: "listOf",
        position: (656, 32),
       },
       arguments: [
        FunctionApplication {
         function: Variable {
          identifier: "submodule",
          position: (656, 40),
         },
         arguments: [
          Function {
           argument: None,
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: true,
           },
           definition: Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (657, 5),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "domain",
                    position: (658, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (658, 16),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (659, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Username, groupname, or wildcard this limit applies to",
                         position: (659, 24),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "example",
                         position: (660, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "@wheel",
                         position: (660, 20),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (661, 9),
                        },
                       ],
                      },
                      Variable {
                       identifier: "str",
                       position: (661, 16),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (658, 25),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (664, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (664, 14),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (665, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Type of this limit",
                         position: (665, 24),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (666, 9),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "enum",
                        position: (666, 16),
                       },
                       arguments: [
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "-",
                             position: (666, 24),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "hard",
                             position: (666, 28),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "soft",
                             position: (666, 35),
                            },
                           ],
                          },
                         ],
                         position: (666, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (667, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "-",
                         position: (667, 20),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (664, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "item",
                    position: (670, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (670, 14),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (671, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Item this limit applies to",
                         position: (671, 24),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (672, 9),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "enum",
                        position: (672, 16),
                       },
                       arguments: [
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "core",
                             position: (673, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "data",
                             position: (674, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "fsize",
                             position: (675, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "memlock",
                             position: (676, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "nofile",
                             position: (677, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "rss",
                             position: (678, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "stack",
                             position: (679, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "cpu",
                             position: (680, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "nproc",
                             position: (681, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "as",
                             position: (682, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "maxlogins",
                             position: (683, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "maxsyslogins",
                             position: (684, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "priority",
                             position: (685, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "locks",
                             position: (686, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "sigpending",
                             position: (687, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "msgqueue",
                             position: (688, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "nice",
                             position: (689, 12),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "rtprio",
                             position: (690, 12),
                            },
                           ],
                          },
                         ],
                         position: (672, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (670, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (694, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (694, 15),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (695, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Value of this limit",
                         position: (695, 24),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (696, 9),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "oneOf",
                        position: (696, 16),
                       },
                       arguments: [
                        List {
                         elements: [
                          Variable {
                           identifier: "str",
                           position: (696, 24),
                          },
                          Variable {
                           identifier: "int",
                           position: (696, 28),
                          },
                         ],
                         position: (696, 22),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (694, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (657, 15),
              },
             ),
            ],
            recursive: false,
            position: (656, 60),
           },
           position: (656, 51),
          },
         ],
        },
       ],
      },
      position: (656, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "motd",
        position: (701, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (701, 10),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (701, 15),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "motd",
          position: (701, 26),
         },
        ],
       },
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (701, 32),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "users",
           position: (701, 39),
          },
          Raw {
           content: "motd",
           position: (701, 45),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makePAMService",
        position: (703, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "service",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "name",
             position: (704, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "pam.d/",
             position: (704, 15),
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (704, 23),
             },
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "value",
             position: (705, 7),
            },
            Raw {
             content: "source",
             position: (705, 13),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "pkgs",
             position: (705, 22),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "writeText",
               position: (705, 27),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Expression {
               expression: Variable {
                identifier: "name",
                position: (705, 40),
               },
              },
              Raw {
               content: ".pam",
               position: (705, 45),
              },
             ],
            },
            PropertyAccess {
             expression: Variable {
              identifier: "service",
              position: (705, 51),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "text",
                position: (705, 59),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (704, 5),
       },
       position: (703, 26),
      },
      position: (703, 20),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (712, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (713, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "security",
               position: (713, 31),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "pam",
               position: (713, 42),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "enableU2F",
               position: (713, 48),
              },
             ],
            },
           ],
           position: (713, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "security",
               position: (713, 64),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "pam",
               position: (713, 75),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "u2f",
               position: (713, 81),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "enable",
               position: (713, 87),
              },
             ],
            },
           ],
           position: (713, 61),
          },
         ],
        },
       ],
       position: (712, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (718, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (720, 5),
           },
           Raw {
            content: "pam",
            position: (720, 14),
           },
           Raw {
            content: "loginLimits",
            position: (720, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (720, 32),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (721, 7),
                },
               ],
              },
              List {
               elements: [],
               position: (721, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (722, 7),
                },
               ],
              },
              Variable {
               identifier: "limitsType",
               position: (722, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (723, 7),
                },
               ],
              },
              List {
               elements: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "domain",
                      position: (724, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "ftp",
                      position: (724, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (725, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "hard",
                      position: (725, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "item",
                      position: (726, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "nproc",
                      position: (726, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "value",
                      position: (727, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "0",
                      position: (727, 23),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (724, 11),
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "domain",
                      position: (729, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "@student",
                      position: (729, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (730, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-",
                      position: (730, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "item",
                      position: (731, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "maxlogins",
                      position: (731, 23),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "value",
                      position: (732, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "4",
                      position: (732, 23),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (729, 11),
                },
               ],
               position: (724, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (736, 6),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Define resource limits that should apply to users or groups.\n         Each item in the list should be an attribute set with a\n         <varname>domain</varname>, <varname>type</varname>,\n         <varname>item</varname>, and <varname>value</varname>\n         attribute.  The syntax and semantics of these attributes\n         must be that described in <citerefentry><refentrytitle>limits.conf</refentrytitle>\n         <manvolnum>5</manvolnum></citerefentry>.\n\n         Note that these limits do not apply to systemd services,\n         whose limits can be changed via <option>systemd.extraConfig</option>\n         instead.\n",
                 position: (737, 10),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (720, 41),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (751, 5),
           },
           Raw {
            content: "pam",
            position: (751, 14),
           },
           Raw {
            content: "services",
            position: (751, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (751, 29),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (752, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (752, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (753, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (753, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (753, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (753, 35),
                  },
                  arguments: [
                   Variable {
                    identifier: "pamOpts",
                    position: (753, 45),
                   },
                  ],
                 },
                ],
               },
               position: (753, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (754, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "This option defines the PAM services.  A service typically\ncorresponds to a program that uses PAM,\ne.g. <command>login</command> or <command>passwd</command>.\nEach attribute of this set defines a PAM service, with the attribute name\ndefining the name of the service.\n",
                 position: (756, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (751, 38),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (764, 5),
           },
           Raw {
            content: "pam",
            position: (764, 14),
           },
           Raw {
            content: "makeHomeDir",
            position: (764, 18),
           },
           Raw {
            content: "skelDirectory",
            position: (764, 30),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (764, 46),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (765, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (765, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (765, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (766, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/var/empty",
                 position: (766, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (767, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/etc/skel",
                 position: (767, 19),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (768, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Path to skeleton directory whose contents are copied to home\ndirectories newly created by <literal>pam_mkhomedir</literal>.\n",
                 position: (769, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (764, 55),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (774, 5),
           },
           Raw {
            content: "pam",
            position: (774, 14),
           },
           Raw {
            content: "enableSSHAgentAuth",
            position: (774, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (774, 39),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (775, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (775, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (775, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (776, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (776, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (777, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Enable sudo logins if the user's SSH agent provides a key\npresent in <filename>~/.ssh/authorized_keys</filename>.\nThis allows machines to exclusively use SSH keys instead of\npasswords.\n",
                 position: (779, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (774, 48),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (786, 5),
           },
           Raw {
            content: "pam",
            position: (786, 14),
           },
           Raw {
            content: "enableOTPW",
            position: (786, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (786, 31),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "the OTPW (one-time password) PAM module",
              position: (786, 47),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (788, 5),
           },
           Raw {
            content: "pam",
            position: (788, 14),
           },
           Raw {
            content: "p11",
            position: (788, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (789, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (789, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (790, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (790, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (791, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (791, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (791, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (792, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enables P11 PAM (<literal>pam_p11</literal>) module.\n\nIf set, users can log in with SSH keys and PKCS#11 tokens.\n\nMore information can be found <link\nxlink:href=\"https://github.com/OpenSC/pam_p11\">here</link>.\n",
                    position: (793, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (789, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (802, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (802, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (803, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                    position: (803, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (804, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (804, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (804, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                        position: (804, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                        position: (804, 41),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                        position: (804, 53),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                        position: (804, 66),
                       },
                      ],
                     },
                    ],
                    position: (804, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (805, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option sets pam \"control\".\nIf you want to have multi factor authentication, use \"required\".\nIf you want to use the PKCS#11 device instead of the regular password,\nuse \"sufficient\".\n\nRead\n<citerefentry>\n  <refentrytitle>pam.conf</refentrytitle>\n  <manvolnum>5</manvolnum>\n</citerefentry>\nfor better understanding of this option.\n",
                    position: (806, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (802, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (788, 24),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (821, 5),
           },
           Raw {
            content: "pam",
            position: (821, 14),
           },
           Raw {
            content: "u2f",
            position: (821, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (822, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (822, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (823, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (823, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (824, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (824, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (824, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (825, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enables U2F PAM (<literal>pam-u2f</literal>) module.\n\nIf set, users listed in\n<filename>$XDG_CONFIG_HOME/Yubico/u2f_keys</filename> (or\n<filename>$HOME/.config/Yubico/u2f_keys</filename> if XDG variable is\nnot set) are able to log in with the associated U2F key. The path can\nbe changed using <option>security.pam.u2f.authFile</option> option.\n\nFile format is:\n<literal>username:first_keyHandle,first_public_key: second_keyHandle,second_public_key</literal>\nThis file can be generated using <command>pamu2fcfg</command> command.\n\nMore information can be found <link\nxlink:href=\"https://developers.yubico.com/pam-u2f/\">here</link>.\n",
                    position: (826, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (822, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "authFile",
               position: (843, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (843, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (844, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (844, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (845, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (845, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (845, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (845, 35),
                    },
                   ],
                  },
                  position: (845, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (846, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "By default <literal>pam-u2f</literal> module reads the keys from\n<filename>$XDG_CONFIG_HOME/Yubico/u2f_keys</filename> (or\n<filename>$HOME/.config/Yubico/u2f_keys</filename> if XDG variable is\nnot set).\n\nIf you want to change auth file locations or centralize database (for\nexample use <filename>/etc/u2f-mappings</filename>) you can set this\noption.\n\nFile format is:\n<literal>username:first_keyHandle,first_public_key: second_keyHandle,second_public_key</literal>\nThis file can be generated using <command>pamu2fcfg</command> command.\n\nMore information can be found <link\nxlink:href=\"https://developers.yubico.com/pam-u2f/\">here</link>.\n",
                    position: (847, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (843, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "appId",
               position: (865, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (865, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (866, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (866, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (867, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (867, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (867, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (867, 35),
                    },
                   ],
                  },
                  position: (867, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (868, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "By default <literal>pam-u2f</literal> module sets the application\nID to <literal>pam://$HOSTNAME</literal>.\n\nWhen using <command>pamu2fcfg</command>, you can specify your\napplication ID with the <literal>-i</literal> flag.\n\nMore information can be found <link\nxlink:href=\"https://developers.yubico.com/pam-u2f/Manuals/pam_u2f.8.html\">\nhere</link>\n",
                    position: (869, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (865, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (881, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (881, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (882, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                    position: (882, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (883, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (883, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (883, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                        position: (883, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                        position: (883, 41),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                        position: (883, 53),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                        position: (883, 66),
                       },
                      ],
                     },
                    ],
                    position: (883, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (884, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option sets pam \"control\".\nIf you want to have multi factor authentication, use \"required\".\nIf you want to use U2F device instead of regular password, use \"sufficient\".\n\nRead\n<citerefentry>\n  <refentrytitle>pam.conf</refentrytitle>\n  <manvolnum>5</manvolnum>\n</citerefentry>\nfor better understanding of this option.\n",
                    position: (885, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (881, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "debug",
               position: (898, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (898, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (899, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (899, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (900, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (900, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (900, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (901, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Debug output to stderr.\n",
                    position: (902, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (898, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "interactive",
               position: (906, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (906, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (907, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (907, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (908, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (908, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (908, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (909, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Set to prompt a message and wait before testing the presence of a U2F device.\nRecommended if your device doesn’t have a tactile trigger.\n",
                    position: (910, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (906, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cue",
               position: (915, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (915, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (916, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (916, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (917, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (917, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (917, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (918, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "By default <literal>pam-u2f</literal> module does not inform user\nthat he needs to use the u2f device, it just waits without a prompt.\n\nIf you set this option to <literal>true</literal>,\n<literal>cue</literal> option is added to <literal>pam-u2f</literal>\nmodule and reminder message will be displayed.\n",
                    position: (919, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (915, 22),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (821, 24),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (929, 5),
           },
           Raw {
            content: "pam",
            position: (929, 14),
           },
           Raw {
            content: "yubico",
            position: (929, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (930, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (930, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (931, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (931, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (932, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (932, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (932, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (933, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enables Yubico PAM (<literal>yubico-pam</literal>) module.\n\nIf set, users listed in\n<filename>~/.yubico/authorized_yubikeys</filename>\nare able to log in with the associated Yubikey tokens.\n\nThe file must have only one line:\n<literal>username:yubikey_token_id1:yubikey_token_id2</literal>\nMore information can be found <link\nxlink:href=\"https://developers.yubico.com/yubico-pam/\">here</link>.\n",
                    position: (934, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (930, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (946, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (946, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (947, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                    position: (947, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (948, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (948, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (948, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                        position: (948, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                        position: (948, 41),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                        position: (948, 53),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                        position: (948, 66),
                       },
                      ],
                     },
                    ],
                    position: (948, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (949, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "This option sets pam \"control\".\nIf you want to have multi factor authentication, use \"required\".\nIf you want to use Yubikey instead of regular password, use \"sufficient\".\n\nRead\n<citerefentry>\n  <refentrytitle>pam.conf</refentrytitle>\n  <manvolnum>5</manvolnum>\n</citerefentry>\nfor better understanding of this option.\n",
                    position: (950, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (946, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "id",
               position: (962, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (962, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (963, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "42",
                    position: (963, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (964, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (964, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (964, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (965, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "client id",
                    position: (965, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (962, 21),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "debug",
               position: (968, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (968, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (969, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (969, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (970, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (970, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (970, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (971, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Debug output to stderr.\n",
                    position: (972, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (968, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mode",
               position: (975, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (975, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (976, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "client",
                    position: (976, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (977, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (977, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (977, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "client",
                        position: (977, 30),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "challenge-response",
                        position: (977, 39),
                       },
                      ],
                     },
                    ],
                    position: (977, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (978, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Mode of operation.\n\nUse \"client\" for online validation with a YubiKey validation service such as\nthe YubiCloud.\n\nUse \"challenge-response\" for offline validation using YubiKeys with HMAC-SHA-1\nChallenge-Response configurations. See the man-page ykpamcfg(1) for further\ndetails on how to configure offline Challenge-Response validation.\n\nMore information can be found <link\nxlink:href=\"https://developers.yubico.com/yubico-pam/Authentication_Using_Challenge-Response.html\">here</link>.\n",
                    position: (979, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (975, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "challengeResponsePath",
               position: (992, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (992, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (993, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (993, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (994, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (994, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (994, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (994, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (994, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (995, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If not null, set the path used by yubico pam module where the challenge expected response is stored.\n\nMore information can be found <link\nxlink:href=\"https://developers.yubico.com/yubico-pam/Authentication_Using_Challenge-Response.html\">here</link>.\n",
                    position: (996, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (992, 40),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (929, 27),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1004, 5),
           },
           Raw {
            content: "pam",
            position: (1004, 14),
           },
           Raw {
            content: "enableEcryptfs",
            position: (1004, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (1004, 35),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "eCryptfs PAM module (mounting ecryptfs home directory on login)",
              position: (1004, 51),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (1006, 5),
           },
           Raw {
            content: "motd",
            position: (1006, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (1006, 18),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (1007, 7),
                },
               ],
              },
              Variable {
               identifier: "null",
               position: (1007, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (1008, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Today is Sweetmorn, the 4th day of The Aftermath in the YOLD 3178.",
                 position: (1008, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (1009, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (1009, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nullOr",
                   position: (1009, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (1009, 27),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "lines",
                    position: (1009, 33),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (1010, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Message of the day shown to users when they log in.",
                 position: (1010, 22),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (1006, 27),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (718, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (1018, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (1020, 5),
           },
           Raw {
            content: "systemPackages",
            position: (1020, 17),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (1022, 9),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "pam",
                 position: (1022, 14),
                },
               ],
              },
              default: None,
             },
            ],
            position: (1022, 7),
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (1023, 10),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (1023, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "users",
                   position: (1023, 26),
                  },
                  Raw {
                   content: "ldap",
                   position: (1023, 32),
                  },
                  Raw {
                   content: "enable",
                   position: (1023, 37),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "pam_ldap",
                position: (1023, 44),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (1024, 10),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (1024, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "services",
                     position: (1024, 26),
                    },
                    Raw {
                     content: "sssd",
                     position: (1024, 35),
                    },
                    Raw {
                     content: "enable",
                     position: (1024, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1024, 47),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "sssd",
                     position: (1024, 52),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionals",
                   position: (1025, 10),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (1025, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "krb5",
                       position: (1025, 27),
                      },
                      Raw {
                       content: "enable",
                       position: (1025, 32),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [
                     Variable {
                      identifier: "pam_krb5",
                      position: (1025, 40),
                     },
                     Variable {
                      identifier: "pam_ccreds",
                      position: (1025, 49),
                     },
                    ],
                    position: (1025, 39),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "optionals",
                     position: (1026, 10),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (1026, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "security",
                         position: (1026, 27),
                        },
                        Raw {
                         content: "pam",
                         position: (1026, 36),
                        },
                        Raw {
                         content: "enableOTPW",
                         position: (1026, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     List {
                      elements: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (1026, 53),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "otpw",
                           position: (1026, 58),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                      position: (1026, 51),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionals",
                       position: (1027, 10),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (1027, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "security",
                           position: (1027, 27),
                          },
                          Raw {
                           content: "pam",
                           position: (1027, 36),
                          },
                          Raw {
                           content: "oath",
                           position: (1027, 40),
                          },
                          Raw {
                           content: "enable",
                           position: (1027, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                       List {
                        elements: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (1027, 54),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "oathToolkit",
                             position: (1027, 59),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (1027, 52),
                       },
                      ],
                     },
                     BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionals",
                         position: (1028, 10),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "config",
                           position: (1028, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "security",
                             position: (1028, 27),
                            },
                            Raw {
                             content: "pam",
                             position: (1028, 36),
                            },
                            Raw {
                             content: "p11",
                             position: (1028, 40),
                            },
                            Raw {
                             content: "enable",
                             position: (1028, 44),
                            },
                           ],
                          },
                          default: None,
                         },
                         List {
                          elements: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1028, 53),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pam_p11",
                               position: (1028, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                          position: (1028, 51),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionals",
                         position: (1029, 10),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "config",
                           position: (1029, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "security",
                             position: (1029, 27),
                            },
                            Raw {
                             content: "pam",
                             position: (1029, 36),
                            },
                            Raw {
                             content: "u2f",
                             position: (1029, 40),
                            },
                            Raw {
                             content: "enable",
                             position: (1029, 44),
                            },
                           ],
                          },
                          default: None,
                         },
                         List {
                          elements: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1029, 53),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pam_u2f",
                               position: (1029, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                          position: (1029, 51),
                         },
                        ],
                       },
                      ],
                      position: (1029, 7),
                     },
                    ],
                    position: (1028, 7),
                   },
                  ],
                  position: (1027, 7),
                 },
                ],
                position: (1026, 7),
               },
              ],
              position: (1025, 7),
             },
            ],
            position: (1024, 7),
           },
          ],
          position: (1023, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (1031, 5),
           },
           Raw {
            content: "supportedFilesystems",
            position: (1031, 10),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "optionals",
           position: (1031, 33),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (1031, 43),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "security",
               position: (1031, 50),
              },
              Raw {
               content: "pam",
               position: (1031, 59),
              },
              Raw {
               content: "enableEcryptfs",
               position: (1031, 63),
              },
             ],
            },
            default: None,
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "ecryptfs",
                position: (1031, 81),
               },
              ],
             },
            ],
            position: (1031, 78),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1033, 5),
           },
           Raw {
            content: "wrappers",
            position: (1033, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unix_chkpwd",
               position: (1034, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "setuid",
                  position: (1035, 9),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (1035, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "owner",
                  position: (1036, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "root",
                  position: (1036, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (1037, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "root",
                  position: (1037, 18),
                 },
                ],
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "source",
                  position: (1038, 9),
                 },
                ],
               },
               String {
                parts: [
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1038, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "pam",
                      position: (1038, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/unix_chkpwd",
                  position: (1038, 30),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (1034, 21),
            },
           ),
          ],
          recursive: false,
          position: (1033, 25),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (1042, 5),
           },
           Raw {
            content: "etc",
            position: (1042, 17),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mapAttrs'",
           position: (1042, 23),
          },
          arguments: [
           Variable {
            identifier: "makePAMService",
            position: (1042, 33),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (1042, 48),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "security",
               position: (1042, 55),
              },
              Raw {
               content: "pam",
               position: (1042, 64),
              },
              Raw {
               content: "services",
               position: (1042, 68),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1044, 5),
           },
           Raw {
            content: "pam",
            position: (1044, 14),
           },
           Raw {
            content: "services",
            position: (1044, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "other",
               position: (1045, 9),
              },
              Raw {
               content: "text",
               position: (1045, 15),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "auth     required pam_warn.so\nauth     required pam_deny.so\naccount  required pam_warn.so\naccount  required pam_deny.so\npassword required pam_warn.so\npassword required pam_deny.so\nsession  required pam_warn.so\nsession  required pam_deny.so\n",
               position: (1047, 1),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "i3lock",
               position: (1058, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1058, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "i3lock-color",
               position: (1059, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1059, 24),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "vlock",
               position: (1060, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1060, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "xlock",
               position: (1061, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1061, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "xscreensaver",
               position: (1062, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1062, 24),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "runuser",
               position: (1064, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "rootOK",
                  position: (1064, 21),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (1064, 30),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unixAuth",
                  position: (1064, 36),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (1064, 47),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "setEnvironment",
                  position: (1064, 54),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (1064, 71),
               },
              ),
             ],
             recursive: false,
             position: (1064, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "runuser-l",
               position: (1069, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "rootOK",
                  position: (1069, 23),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (1069, 32),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unixAuth",
                  position: (1069, 38),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (1069, 49),
               },
              ),
             ],
             recursive: false,
             position: (1069, 21),
            },
           ),
          ],
          recursive: false,
          position: (1045, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1072, 5),
           },
           Raw {
            content: "apparmor",
            position: (1072, 14),
           },
           Raw {
            content: "includes",
            position: (1072, 23),
           },
           Expression {
            expression: String {
             parts: [
              Raw {
               content: "abstractions/pam",
               position: (1072, 33),
              },
             ],
            },
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isEnabled",
               position: (1073, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "test",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "fold",
               position: (1073, 25),
              },
              arguments: [
               Variable {
                identifier: "or",
                position: (1073, 30),
               },
               Variable {
                identifier: "false",
                position: (1073, 33),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (1073, 40),
                },
                arguments: [
                 Variable {
                  identifier: "test",
                  position: (1073, 44),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "attrValues",
                   position: (1073, 50),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (1073, 61),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (1073, 68),
                      },
                      Raw {
                       content: "pam",
                       position: (1073, 77),
                      },
                      Raw {
                       content: "services",
                       position: (1073, 81),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ],
               },
              ],
             },
             position: (1073, 19),
            },
           ),
          ],
          target: BinaryOperation {
           operator: Addition,
           operands: [
            BinaryOperation {
             operator: Addition,
             operands: [
              BinaryOperation {
               operator: Addition,
               operands: [
                BinaryOperation {
                 operator: Addition,
                 operands: [
                  BinaryOperation {
                   operator: Addition,
                   operands: [
                    BinaryOperation {
                     operator: Addition,
                     operands: [
                      BinaryOperation {
                       operator: Addition,
                       operands: [
                        BinaryOperation {
                         operator: Addition,
                         operands: [
                          BinaryOperation {
                           operator: Addition,
                           operands: [
                            BinaryOperation {
                             operator: Addition,
                             operands: [
                              BinaryOperation {
                               operator: Addition,
                               operands: [
                                BinaryOperation {
                                 operator: Addition,
                                 operands: [
                                  BinaryOperation {
                                   operator: Addition,
                                   operands: [
                                    BinaryOperation {
                                     operator: Addition,
                                     operands: [
                                      BinaryOperation {
                                       operator: Addition,
                                       operands: [
                                        BinaryOperation {
                                         operator: Addition,
                                         operands: [
                                          BinaryOperation {
                                           operator: Addition,
                                           operands: [
                                            BinaryOperation {
                                             operator: Addition,
                                             operands: [
                                              BinaryOperation {
                                               operator: Addition,
                                               operands: [
                                                BinaryOperation {
                                                 operator: Addition,
                                                 operands: [
                                                  BinaryOperation {
                                                   operator: Addition,
                                                   operands: [
                                                    FunctionApplication {
                                                     function: PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "lib",
                                                       position: (1075, 7),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "concatMapStrings",
                                                         position: (1075, 11),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                     arguments: [
                                                      Function {
                                                       argument: Some(
                                                        "name",
                                                       ),
                                                       arguments: FunctionArguments {
                                                        arguments: [],
                                                        ellipsis: false,
                                                       },
                                                       definition: String {
                                                        parts: [
                                                         Raw {
                                                          content: "r ",
                                                          position: (1076, 17),
                                                         },
                                                         Expression {
                                                          expression: PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "config",
                                                            position: (1076, 21),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "environment",
                                                              position: (1076, 28),
                                                             },
                                                             Raw {
                                                              content: "etc",
                                                              position: (1076, 40),
                                                             },
                                                             Expression {
                                                              expression: String {
                                                               parts: [
                                                                Raw {
                                                                 content: "pam.d/",
                                                                 position: (1076, 45),
                                                                },
                                                                Expression {
                                                                 expression: Variable {
                                                                  identifier: "name",
                                                                  position: (1076, 53),
                                                                 },
                                                                },
                                                               ],
                                                              },
                                                             },
                                                             Raw {
                                                              content: "source",
                                                              position: (1076, 60),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         },
                                                         Raw {
                                                          content: ",\n",
                                                          position: (1076, 67),
                                                         },
                                                        ],
                                                       },
                                                       position: (1076, 10),
                                                      },
                                                      FunctionApplication {
                                                       function: Variable {
                                                        identifier: "attrNames",
                                                        position: (1077, 10),
                                                       },
                                                       arguments: [
                                                        PropertyAccess {
                                                         expression: Variable {
                                                          identifier: "config",
                                                          position: (1077, 20),
                                                         },
                                                         attribute_path: AttributePath {
                                                          attributes: [
                                                           Raw {
                                                            content: "security",
                                                            position: (1077, 27),
                                                           },
                                                           Raw {
                                                            content: "pam",
                                                            position: (1077, 36),
                                                           },
                                                           Raw {
                                                            content: "services",
                                                            position: (1077, 40),
                                                           },
                                                          ],
                                                         },
                                                         default: None,
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                    },
                                                    String {
                                                     parts: [
                                                      Raw {
                                                       content: "mr ",
                                                       position: (1079, 1),
                                                      },
                                                      Expression {
                                                       expression: FunctionApplication {
                                                        function: Variable {
                                                         identifier: "getLib",
                                                         position: (1079, 12),
                                                        },
                                                        arguments: [
                                                         PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "pkgs",
                                                           position: (1079, 19),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "pam",
                                                             position: (1079, 24),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                        ],
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/pam_filter/*,\nmr ",
                                                       position: (1079, 28),
                                                      },
                                                      Expression {
                                                       expression: FunctionApplication {
                                                        function: Variable {
                                                         identifier: "getLib",
                                                         position: (1080, 12),
                                                        },
                                                        arguments: [
                                                         PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "pkgs",
                                                           position: (1080, 19),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "pam",
                                                             position: (1080, 24),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                        ],
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/pam_*.so,\nr ",
                                                       position: (1080, 28),
                                                      },
                                                      Expression {
                                                       expression: FunctionApplication {
                                                        function: Variable {
                                                         identifier: "getLib",
                                                         position: (1081, 11),
                                                        },
                                                        arguments: [
                                                         PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "pkgs",
                                                           position: (1081, 18),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "pam",
                                                             position: (1081, 23),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                        ],
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/,\n",
                                                       position: (1081, 27),
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                   position: (1077, 50),
                                                  },
                                                  FunctionApplication {
                                                   function: Variable {
                                                    identifier: "optionalString",
                                                    position: (1083, 7),
                                                   },
                                                   arguments: [
                                                    Variable {
                                                     identifier: "use_ldap",
                                                     position: (1083, 22),
                                                    },
                                                    String {
                                                     parts: [
                                                      Raw {
                                                       content: "mr ",
                                                       position: (1084, 1),
                                                      },
                                                      Expression {
                                                       expression: Variable {
                                                        identifier: "pam_ldap",
                                                        position: (1084, 15),
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/pam_ldap.so,\n",
                                                       position: (1084, 24),
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                 position: (1082, 10),
                                                },
                                                FunctionApplication {
                                                 function: Variable {
                                                  identifier: "optionalString",
                                                  position: (1086, 7),
                                                 },
                                                 arguments: [
                                                  PropertyAccess {
                                                   expression: Variable {
                                                    identifier: "config",
                                                    position: (1086, 22),
                                                   },
                                                   attribute_path: AttributePath {
                                                    attributes: [
                                                     Raw {
                                                      content: "services",
                                                      position: (1086, 29),
                                                     },
                                                     Raw {
                                                      content: "sssd",
                                                      position: (1086, 38),
                                                     },
                                                     Raw {
                                                      content: "enable",
                                                      position: (1086, 43),
                                                     },
                                                    ],
                                                   },
                                                   default: None,
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "mr ",
                                                     position: (1087, 1),
                                                    },
                                                    Expression {
                                                     expression: PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "pkgs",
                                                       position: (1087, 14),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "sssd",
                                                         position: (1087, 19),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    },
                                                    Raw {
                                                     content: "/lib/security/pam_sss.so,\n",
                                                     position: (1087, 24),
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                },
                                               ],
                                               position: (1085, 10),
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "optionalString",
                                                position: (1089, 7),
                                               },
                                               arguments: [
                                                PropertyAccess {
                                                 expression: Variable {
                                                  identifier: "config",
                                                  position: (1089, 22),
                                                 },
                                                 attribute_path: AttributePath {
                                                  attributes: [
                                                   Raw {
                                                    content: "krb5",
                                                    position: (1089, 29),
                                                   },
                                                   Raw {
                                                    content: "enable",
                                                    position: (1089, 34),
                                                   },
                                                  ],
                                                 },
                                                 default: None,
                                                },
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "mr ",
                                                   position: (1090, 1),
                                                  },
                                                  Expression {
                                                   expression: Variable {
                                                    identifier: "pam_krb5",
                                                    position: (1090, 14),
                                                   },
                                                  },
                                                  Raw {
                                                   content: "/lib/security/pam_krb5.so,\nmr ",
                                                   position: (1090, 23),
                                                  },
                                                  Expression {
                                                   expression: Variable {
                                                    identifier: "pam_ccreds",
                                                    position: (1091, 14),
                                                   },
                                                  },
                                                  Raw {
                                                   content: "/lib/security/pam_ccreds.so,\n",
                                                   position: (1091, 25),
                                                  },
                                                 ],
                                                },
                                               ],
                                              },
                                             ],
                                             position: (1088, 10),
                                            },
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "optionalString",
                                              position: (1093, 7),
                                             },
                                             arguments: [
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "isEnabled",
                                                position: (1093, 23),
                                               },
                                               arguments: [
                                                Function {
                                                 argument: Some(
                                                  "cfg",
                                                 ),
                                                 arguments: FunctionArguments {
                                                  arguments: [],
                                                  ellipsis: false,
                                                 },
                                                 definition: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "cfg",
                                                   position: (1093, 39),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "googleOsLoginAccountVerification",
                                                     position: (1093, 43),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 position: (1093, 34),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "mr ",
                                                 position: (1094, 1),
                                                },
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "pkgs",
                                                   position: (1094, 14),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "google-guest-oslogin",
                                                     position: (1094, 19),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: "/lib/security/pam_oslogin_login.so,\nmr ",
                                                 position: (1094, 40),
                                                },
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "pkgs",
                                                   position: (1095, 14),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "google-guest-oslogin",
                                                     position: (1095, 19),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: "/lib/security/pam_oslogin_admin.so,\n",
                                                 position: (1095, 40),
                                                },
                                               ],
                                              },
                                             ],
                                            },
                                           ],
                                           position: (1092, 10),
                                          },
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "optionalString",
                                            position: (1097, 7),
                                           },
                                           arguments: [
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "isEnabled",
                                              position: (1097, 23),
                                             },
                                             arguments: [
                                              Function {
                                               argument: Some(
                                                "cfg",
                                               ),
                                               arguments: FunctionArguments {
                                                arguments: [],
                                                ellipsis: false,
                                               },
                                               definition: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "cfg",
                                                 position: (1097, 39),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "googleOsLoginAuthentication",
                                                   position: (1097, 43),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               position: (1097, 34),
                                              },
                                             ],
                                            },
                                            String {
                                             parts: [
                                              Raw {
                                               content: "mr ",
                                               position: (1098, 1),
                                              },
                                              Expression {
                                               expression: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "pkgs",
                                                 position: (1098, 14),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "google-guest-oslogin",
                                                   position: (1098, 19),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                              },
                                              Raw {
                                               content: "/lib/security/pam_oslogin_login.so,\n",
                                               position: (1098, 40),
                                              },
                                             ],
                                            },
                                           ],
                                          },
                                         ],
                                         position: (1096, 10),
                                        },
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "optionalString",
                                          position: (1100, 7),
                                         },
                                         arguments: [
                                          BinaryOperation {
                                           operator: LogicalAnd,
                                           operands: [
                                            PropertyAccess {
                                             expression: Variable {
                                              identifier: "config",
                                              position: (1100, 23),
                                             },
                                             attribute_path: AttributePath {
                                              attributes: [
                                               Raw {
                                                content: "security",
                                                position: (1100, 30),
                                               },
                                               Raw {
                                                content: "pam",
                                                position: (1100, 39),
                                               },
                                               Raw {
                                                content: "enableSSHAgentAuth",
                                                position: (1100, 43),
                                               },
                                              ],
                                             },
                                             default: None,
                                            },
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "isEnabled",
                                              position: (1101, 25),
                                             },
                                             arguments: [
                                              Function {
                                               argument: Some(
                                                "cfg",
                                               ),
                                               arguments: FunctionArguments {
                                                arguments: [],
                                                ellipsis: false,
                                               },
                                               definition: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "cfg",
                                                 position: (1101, 41),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "sshAgentAuth",
                                                   position: (1101, 45),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                               position: (1101, 36),
                                              },
                                             ],
                                            },
                                           ],
                                           position: (1101, 22),
                                          },
                                          String {
                                           parts: [
                                            Raw {
                                             content: "mr ",
                                             position: (1102, 1),
                                            },
                                            Expression {
                                             expression: PropertyAccess {
                                              expression: Variable {
                                               identifier: "pkgs",
                                               position: (1102, 14),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "pam_ssh_agent_auth",
                                                 position: (1102, 19),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                            },
                                            Raw {
                                             content: "/libexec/pam_ssh_agent_auth.so,\n",
                                             position: (1102, 38),
                                            },
                                           ],
                                          },
                                         ],
                                        },
                                       ],
                                       position: (1099, 10),
                                      },
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "optionalString",
                                        position: (1104, 7),
                                       },
                                       arguments: [
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "isEnabled",
                                          position: (1104, 23),
                                         },
                                         arguments: [
                                          Function {
                                           argument: Some(
                                            "cfg",
                                           ),
                                           arguments: FunctionArguments {
                                            arguments: [],
                                            ellipsis: false,
                                           },
                                           definition: PropertyAccess {
                                            expression: Variable {
                                             identifier: "cfg",
                                             position: (1104, 39),
                                            },
                                            attribute_path: AttributePath {
                                             attributes: [
                                              Raw {
                                               content: "fprintAuth",
                                               position: (1104, 43),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                           position: (1104, 34),
                                          },
                                         ],
                                        },
                                        String {
                                         parts: [
                                          Raw {
                                           content: "mr ",
                                           position: (1105, 1),
                                          },
                                          Expression {
                                           expression: PropertyAccess {
                                            expression: Variable {
                                             identifier: "pkgs",
                                             position: (1105, 14),
                                            },
                                            attribute_path: AttributePath {
                                             attributes: [
                                              Raw {
                                               content: "fprintd",
                                               position: (1105, 19),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                          },
                                          Raw {
                                           content: "/lib/security/pam_fprintd.so,\n",
                                           position: (1105, 27),
                                          },
                                         ],
                                        },
                                       ],
                                      },
                                     ],
                                     position: (1103, 10),
                                    },
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "optionalString",
                                      position: (1107, 7),
                                     },
                                     arguments: [
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "isEnabled",
                                        position: (1107, 23),
                                       },
                                       arguments: [
                                        Function {
                                         argument: Some(
                                          "cfg",
                                         ),
                                         arguments: FunctionArguments {
                                          arguments: [],
                                          ellipsis: false,
                                         },
                                         definition: PropertyAccess {
                                          expression: Variable {
                                           identifier: "cfg",
                                           position: (1107, 39),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "u2fAuth",
                                             position: (1107, 43),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                         position: (1107, 34),
                                        },
                                       ],
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "mr ",
                                         position: (1108, 1),
                                        },
                                        Expression {
                                         expression: PropertyAccess {
                                          expression: Variable {
                                           identifier: "pkgs",
                                           position: (1108, 14),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "pam_u2f",
                                             position: (1108, 19),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                        },
                                        Raw {
                                         content: "/lib/security/pam_u2f.so,\n",
                                         position: (1108, 27),
                                        },
                                       ],
                                      },
                                     ],
                                    },
                                   ],
                                   position: (1106, 10),
                                  },
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "optionalString",
                                    position: (1110, 7),
                                   },
                                   arguments: [
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "isEnabled",
                                      position: (1110, 23),
                                     },
                                     arguments: [
                                      Function {
                                       argument: Some(
                                        "cfg",
                                       ),
                                       arguments: FunctionArguments {
                                        arguments: [],
                                        ellipsis: false,
                                       },
                                       definition: PropertyAccess {
                                        expression: Variable {
                                         identifier: "cfg",
                                         position: (1110, 39),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "usbAuth",
                                           position: (1110, 43),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                       position: (1110, 34),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "mr ",
                                       position: (1111, 1),
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (1111, 14),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "pam_usb",
                                           position: (1111, 19),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/lib/security/pam_usb.so,\n",
                                       position: (1111, 27),
                                      },
                                     ],
                                    },
                                   ],
                                  },
                                 ],
                                 position: (1109, 10),
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "optionalString",
                                  position: (1113, 7),
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "isEnabled",
                                    position: (1113, 23),
                                   },
                                   arguments: [
                                    Function {
                                     argument: Some(
                                      "cfg",
                                     ),
                                     arguments: FunctionArguments {
                                      arguments: [],
                                      ellipsis: false,
                                     },
                                     definition: PropertyAccess {
                                      expression: Variable {
                                       identifier: "cfg",
                                       position: (1113, 39),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "oathAuth",
                                         position: (1113, 43),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                     position: (1113, 34),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "\"mr ",
                                     position: (1114, 1),
                                    },
                                    Expression {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "pkgs",
                                       position: (1114, 15),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "oathToolkit",
                                         position: (1114, 20),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                    Raw {
                                     content: "/lib/security/pam_oath.so,\n",
                                     position: (1114, 32),
                                    },
                                   ],
                                  },
                                 ],
                                },
                               ],
                               position: (1112, 10),
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "optionalString",
                                position: (1116, 7),
                               },
                               arguments: [
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "isEnabled",
                                  position: (1116, 23),
                                 },
                                 arguments: [
                                  Function {
                                   argument: Some(
                                    "cfg",
                                   ),
                                   arguments: FunctionArguments {
                                    arguments: [],
                                    ellipsis: false,
                                   },
                                   definition: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (1116, 39),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "yubicoAuth",
                                       position: (1116, 43),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   position: (1116, 34),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "mr ",
                                   position: (1117, 1),
                                  },
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (1117, 14),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "yubico-pam",
                                       position: (1117, 19),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/lib/security/pam_yubico.so,\n",
                                   position: (1117, 30),
                                  },
                                 ],
                                },
                               ],
                              },
                             ],
                             position: (1115, 10),
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "optionalString",
                              position: (1119, 7),
                             },
                             arguments: [
                              FunctionApplication {
                               function: Variable {
                                identifier: "isEnabled",
                                position: (1119, 23),
                               },
                               arguments: [
                                Function {
                                 argument: Some(
                                  "cfg",
                                 ),
                                 arguments: FunctionArguments {
                                  arguments: [],
                                  ellipsis: false,
                                 },
                                 definition: PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (1119, 39),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "duoSecurity",
                                     position: (1119, 43),
                                    },
                                    Raw {
                                     content: "enable",
                                     position: (1119, 55),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 position: (1119, 34),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "mr ",
                                 position: (1120, 1),
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (1120, 14),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "duo-unix",
                                     position: (1120, 19),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/lib/security/pam_duo.so,\n",
                                 position: (1120, 28),
                                },
                               ],
                              },
                             ],
                            },
                           ],
                           position: (1118, 10),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "optionalString",
                            position: (1122, 7),
                           },
                           arguments: [
                            FunctionApplication {
                             function: Variable {
                              identifier: "isEnabled",
                              position: (1122, 23),
                             },
                             arguments: [
                              Function {
                               argument: Some(
                                "cfg",
                               ),
                               arguments: FunctionArguments {
                                arguments: [],
                                ellipsis: false,
                               },
                               definition: PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (1122, 39),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "otpwAuth",
                                   position: (1122, 43),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               position: (1122, 34),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "mr ",
                               position: (1123, 1),
                              },
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (1123, 14),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "otpw",
                                   position: (1123, 19),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: "/lib/security/pam_otpw.so,\n",
                               position: (1123, 24),
                              },
                             ],
                            },
                           ],
                          },
                         ],
                         position: (1121, 10),
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "optionalString",
                          position: (1125, 7),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "config",
                            position: (1125, 22),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "security",
                              position: (1125, 29),
                             },
                             Raw {
                              content: "pam",
                              position: (1125, 38),
                             },
                             Raw {
                              content: "enableEcryptfs",
                              position: (1125, 42),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [
                            Raw {
                             content: "mr ",
                             position: (1126, 1),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (1126, 14),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "ecryptfs",
                                 position: (1126, 19),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/lib/security/pam_ecryptfs.so,\n",
                             position: (1126, 28),
                            },
                           ],
                          },
                         ],
                        },
                       ],
                       position: (1124, 10),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (1128, 7),
                       },
                       arguments: [
                        FunctionApplication {
                         function: Variable {
                          identifier: "isEnabled",
                          position: (1128, 23),
                         },
                         arguments: [
                          Function {
                           argument: Some(
                            "cfg",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1128, 39),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pamMount",
                               position: (1128, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                           position: (1128, 34),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mr ",
                           position: (1129, 1),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1129, 14),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pam_mount",
                               position: (1129, 19),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/lib/security/pam_mount.so,\n",
                           position: (1129, 29),
                          },
                         ],
                        },
                       ],
                      },
                     ],
                     position: (1127, 10),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (1131, 7),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "isEnabled",
                        position: (1131, 23),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "cfg",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1131, 39),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "enableGnomeKeyring",
                             position: (1131, 43),
                            },
                           ],
                          },
                          default: None,
                         },
                         position: (1131, 34),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mr ",
                         position: (1132, 1),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (1132, 14),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "gnome3",
                             position: (1132, 19),
                            },
                            Raw {
                             content: "gnome-keyring",
                             position: (1132, 26),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/lib/security/pam_gnome_keyring.so,\n",
                         position: (1132, 40),
                        },
                       ],
                      },
                     ],
                    },
                   ],
                   position: (1130, 10),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optionalString",
                    position: (1134, 7),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "isEnabled",
                      position: (1134, 23),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "cfg",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1134, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "startSession",
                           position: (1134, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                       position: (1134, 34),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mr ",
                       position: (1135, 1),
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (1135, 14),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "systemd",
                           position: (1135, 19),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/lib/security/pam_systemd.so,\n",
                       position: (1135, 27),
                      },
                     ],
                    },
                   ],
                  },
                 ],
                 position: (1133, 10),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (1137, 7),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "isEnabled",
                      position: (1137, 23),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "cfg",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1137, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "enableAppArmor",
                           position: (1137, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                       position: (1137, 34),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1138, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (1138, 32),
                       },
                       Raw {
                        content: "apparmor",
                        position: (1138, 41),
                       },
                       Raw {
                        content: "enable",
                        position: (1138, 50),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (1138, 22),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mr ",
                     position: (1139, 1),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (1139, 14),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "apparmor-pam",
                         position: (1139, 19),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/lib/security/pam_apparmor.so,\n",
                     position: (1139, 32),
                    },
                   ],
                  },
                 ],
                },
               ],
               position: (1136, 10),
              },
              FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (1141, 7),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "isEnabled",
                  position: (1141, 23),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "cfg",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1141, 39),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enableKwallet",
                       position: (1141, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (1141, 34),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "mr ",
                   position: (1142, 1),
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (1142, 14),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "plasma5Packages",
                       position: (1142, 19),
                      },
                      Raw {
                       content: "kwallet-pam",
                       position: (1142, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/lib/security/pam_kwallet5.so,\n",
                   position: (1142, 47),
                  },
                 ],
                },
               ],
              },
             ],
             position: (1140, 10),
            },
            FunctionApplication {
             function: Variable {
              identifier: "optionalString",
              position: (1144, 7),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (1144, 22),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "virtualisation",
                  position: (1144, 29),
                 },
                 Raw {
                  content: "lxc",
                  position: (1144, 44),
                 },
                 Raw {
                  content: "lxcfs",
                  position: (1144, 48),
                 },
                 Raw {
                  content: "enable",
                  position: (1144, 54),
                 },
                ],
               },
               default: None,
              },
              String {
               parts: [
                Raw {
                 content: "mr ",
                 position: (1145, 1),
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1145, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lxc",
                     position: (1145, 19),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/lib/security/pam_cgfs.so\n",
                 position: (1145, 23),
                },
               ],
              },
             ],
            },
           ],
           position: (1143, 10),
          },
          position: (1072, 53),
         },
        ),
       ],
       recursive: false,
       position: (1018, 12),
      },
     ),
    ],
    recursive: false,
    position: (710, 1),
   },
   position: (8, 1),
  },
  position: (6, 1),
 },
 position: (4, 1),
}