---
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, 19),
                   },
                  ),
                  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, 23),
                   },
                  ),
                 ],
                 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: (24, 23),
                   },
                  ),
                 ],
                 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: (33, 23),
                   },
                  ),
                 ],
                 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, 41),
                     },
                    ],
                   },
                  ),
                  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: (43, 23),
                   },
                  ),
                 ],
                 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, 41),
                     },
                    ],
                   },
                  ),
                  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: (55, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (51, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "usshAuth",
                 position: (64, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (64, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (65, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (65, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (66, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (66, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (66, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (67, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, users with an SSH certificate containing an authorized principal\nin their SSH agent are able to log in. Specific options are controlled\nusing the <option>security.pam.ussh</option> options.\n\nNote that the  <option>security.pam.ussh.enable</option> must also be\nset for this option to take effect.\n",
                     },
                    ],
                    position: (67, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (64, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "yubicoAuth",
                 position: (77, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (77, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (78, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (78, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (78, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (78, 35),
                      },
                      Raw {
                       content: "yubico",
                       position: (78, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (78, 46),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (79, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (79, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.yubico.enable",
                       },
                      ],
                      position: (79, 41),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (80, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (80, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (80, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (81, 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: (81, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (77, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "googleAuthenticator",
                 position: (88, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (89, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (89, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (90, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (90, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (91, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (91, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (91, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (92, 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: (92, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (89, 27),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (88, 29),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "usbAuth",
                 position: (100, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (100, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (101, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (101, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (101, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (101, 35),
                      },
                      Raw {
                       content: "usb",
                       position: (101, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (101, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (102, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (102, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.usb.enable",
                       },
                      ],
                      position: (102, 41),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (103, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (103, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (103, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (104, 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: (104, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (100, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "otpwAuth",
                 position: (111, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (111, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (112, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (112, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (112, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (112, 35),
                      },
                      Raw {
                       content: "enableOTPW",
                       position: (112, 39),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (113, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (113, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.enableOTPW",
                       },
                      ],
                      position: (113, 41),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (114, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (114, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (114, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (115, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, the OTPW system will be used (if\n<filename>~/.otpw</filename> exists).\n",
                     },
                    ],
                    position: (115, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (111, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "googleOsLoginAccountVerification",
                 position: (121, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (121, 42),
               },
               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 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: (124, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (121, 51),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "googleOsLoginAuthentication",
                 position: (134, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (134, 37),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (135, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (135, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (136, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (136, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (136, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (137, 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: (137, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (134, 46),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "fprintAuth",
                 position: (145, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (145, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (146, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (146, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "services",
                       position: (146, 26),
                      },
                      Raw {
                       content: "fprintd",
                       position: (146, 35),
                      },
                      Raw {
                       content: "enable",
                       position: (146, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (147, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (147, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.services.fprintd.enable",
                       },
                      ],
                      position: (147, 41),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (148, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (148, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (148, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (149, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, fingerprint reader will be used (if exists and\nyour fingerprints are enrolled).\n",
                     },
                    ],
                    position: (149, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (145, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "oathAuth",
                 position: (155, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (155, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (156, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (156, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (156, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (156, 35),
                      },
                      Raw {
                       content: "oath",
                       position: (156, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (156, 44),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (157, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (157, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.oath.enable",
                       },
                      ],
                      position: (157, 41),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (158, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (158, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (158, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (159, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "If set, the OATH Toolkit will be used.\n",
                     },
                    ],
                    position: (159, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (155, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "sshAgentAuth",
                 position: (164, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (164, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (165, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (165, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (166, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (166, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (166, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (167, 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: (167, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (164, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "duoSecurity",
                 position: (175, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (176, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (176, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (177, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (177, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (178, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (178, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (178, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (179, 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: (179, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (176, 27),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (175, 21),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "startSession",
                 position: (187, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (187, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (188, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (188, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (189, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (189, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (189, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (190, 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: (190, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (187, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "setEnvironment",
                 position: (199, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (199, 24),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (200, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (200, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (200, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (201, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "true",
                    position: (201, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (202, 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: (202, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (199, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "setLoginUid",
                 position: (209, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (209, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (210, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (210, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (210, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (211, 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: (211, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (209, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "ttyAudit",
                 position: (220, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (221, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (221, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (222, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (222, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (222, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (223, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (223, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (224, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Enable or disable TTY auditing for specified users\n",
                        },
                       ],
                       position: (224, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (221, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enablePattern",
                    position: (229, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (229, 25),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (230, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (230, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "nullOr",
                           position: (230, 24),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (230, 31),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "str",
                            position: (230, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (231, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "null",
                       position: (231, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (232, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "For each user matching one of comma-separated\nglob patterns, enable TTY auditing\n",
                        },
                       ],
                       position: (232, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (229, 34),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "disablePattern",
                    position: (238, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (238, 26),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (239, 11),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: PropertyAccess {
                        expression: Variable {
                         identifier: "types",
                         position: (239, 18),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "nullOr",
                           position: (239, 24),
                          },
                         ],
                        },
                        default: None,
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "types",
                          position: (239, 31),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "str",
                            position: (239, 37),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (240, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "null",
                       position: (240, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (241, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "For each user matching one of comma-separated\nglob patterns, disable TTY auditing\n",
                        },
                       ],
                       position: (241, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (238, 35),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "openOnly",
                    position: (247, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (247, 20),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (248, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (248, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (248, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (249, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (249, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (250, 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: (250, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (247, 29),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (220, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "forwardXAuth",
                 position: (260, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (260, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (261, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (261, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (262, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (262, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (262, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (263, 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: (263, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (260, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "pamMount",
                 position: (270, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (270, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (271, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (271, 19),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (271, 26),
                      },
                      Raw {
                       content: "pam",
                       position: (271, 35),
                      },
                      Raw {
                       content: "mount",
                       position: (271, 39),
                      },
                      Raw {
                       content: "enable",
                       position: (271, 45),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "defaultText",
                      position: (272, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: Variable {
                     identifier: "literalExpression",
                     position: (272, 23),
                    },
                    arguments: [
                     String {
                      parts: [
                       Raw {
                        content: "config.security.pam.mount.enable",
                       },
                      ],
                      position: (272, 41),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (273, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (273, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (273, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (274, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Enable PAM mount (pam_mount) system to mount fileystems on user login.\n",
                     },
                    ],
                    position: (274, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (270, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "allowNullPassword",
                 position: (279, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (279, 27),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (280, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (280, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (281, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (281, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (281, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (282, 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: (282, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (279, 36),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "nodelay",
                 position: (294, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (294, 17),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (295, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (295, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (296, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (296, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (296, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (297, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Wheather the delay after typing a wrong password should be disabled.\n",
                     },
                    ],
                    position: (297, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (294, 26),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "requireWheel",
                 position: (302, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (302, 22),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (303, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (303, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (304, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (304, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (304, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (305, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to permit root access only to members of group wheel.\n",
                     },
                    ],
                    position: (305, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (302, 31),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "limits",
                 position: (310, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (310, 16),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (311, 9),
                     },
                    ],
                   },
                   List {
                    elements: [],
                    position: (311, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (312, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "limitsType",
                    position: (312, 16),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (313, 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: (313, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (310, 25),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "showMotd",
                 position: (322, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (322, 18),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (323, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (323, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (324, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (324, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (324, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (325, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to show the message of the day.",
                     },
                    ],
                    position: (325, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (322, 27),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "makeHomeDir",
                 position: (328, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (328, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (329, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (329, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (330, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (330, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (330, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (331, 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: (331, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (328, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "updateWtmp",
                 position: (338, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (338, 20),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (339, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (339, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (340, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (340, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (340, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (341, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to update <filename>/var/log/wtmp</filename>.",
                     },
                    ],
                    position: (341, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (338, 29),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "logFailures",
                 position: (344, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (344, 21),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (345, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (345, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (346, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (346, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (346, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (347, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Whether to log authentication failures in <filename>/var/log/faillog</filename>.",
                     },
                    ],
                    position: (347, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (344, 30),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enableAppArmor",
                 position: (350, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (350, 24),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (351, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (351, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (352, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (352, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (352, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (353, 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: (353, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (350, 33),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enableKwallet",
                 position: (360, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (360, 23),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (361, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (361, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (362, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (362, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (362, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (363, 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: (363, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (360, 32),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "sssdStrictAccess",
                 position: (370, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (370, 26),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (371, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (371, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (372, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (372, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (372, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (373, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "enforce sssd access control",
                     },
                    ],
                    position: (373, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (370, 35),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "enableGnomeKeyring",
                 position: (376, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (376, 28),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "default",
                      position: (377, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "false",
                    position: (377, 19),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (378, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (378, 16),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "bool",
                       position: (378, 22),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (379, 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: (379, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (376, 37),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "gnupg",
                 position: (387, 7),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "enable",
                    position: (388, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (388, 18),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (389, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (389, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (389, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (390, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (390, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (391, 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: (391, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (388, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "noAutostart",
                    position: (403, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (403, 23),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (404, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (404, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (404, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (405, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (405, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (406, 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: (406, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (403, 32),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "storeOnly",
                    position: (413, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (413, 21),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (414, 11),
                        },
                       ],
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "types",
                        position: (414, 18),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "bool",
                          position: (414, 24),
                         },
                        ],
                       },
                       default: None,
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (415, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "false",
                       position: (415, 21),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (416, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Don't send the password immediately after login, but store for PAM\n<literal>session</literal>.\n",
                        },
                       ],
                       position: (416, 25),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (413, 30),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (387, 15),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "text",
                 position: (423, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkOption",
                position: (423, 14),
               },
               arguments: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (424, 9),
                     },
                    ],
                   },
                   FunctionApplication {
                    function: PropertyAccess {
                     expression: Variable {
                      identifier: "types",
                      position: (424, 16),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "nullOr",
                        position: (424, 22),
                       },
                      ],
                     },
                     default: None,
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "types",
                       position: (424, 29),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "lines",
                         position: (424, 35),
                        },
                       ],
                      },
                      default: None,
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (425, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Contents of the PAM service file.",
                     },
                    ],
                    position: (425, 23),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (423, 23),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (13, 15),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "config",
              position: (433, 5),
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "name",
                 position: (434, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (434, 14),
               },
               arguments: [
                Variable {
                 identifier: "name",
                 position: (434, 24),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "setLoginUid",
                 position: (435, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (435, 21),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (435, 31),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "startSession",
                    position: (435, 35),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "limits",
                 position: (436, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (436, 16),
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (436, 26),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "security",
                    position: (436, 33),
                   },
                   Raw {
                    content: "pam",
                    position: (436, 42),
                   },
                   Raw {
                    content: "loginLimits",
                    position: (436, 46),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "text",
                 position: (441, 7),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "mkDefault",
                position: (441, 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: [
                                                                                                                        BinaryOperation {
                                                                                                                         operator: Addition,
                                                                                                                         operands: [
                                                                                                                          String {
                                                                                                                           parts: [
                                                                                                                            Raw {
                                                                                                                             content: "# Account management.\naccount required pam_unix.so\n",
                                                                                                                            },
                                                                                                                           ],
                                                                                                                           position: (443, 11),
                                                                                                                          },
                                                                                                                          FunctionApplication {
                                                                                                                           function: Variable {
                                                                                                                            identifier: "optionalString",
                                                                                                                            position: (447, 11),
                                                                                                                           },
                                                                                                                           arguments: [
                                                                                                                            Variable {
                                                                                                                             identifier: "use_ldap",
                                                                                                                             position: (447, 26),
                                                                                                                            },
                                                                                                                            String {
                                                                                                                             parts: [
                                                                                                                              Raw {
                                                                                                                               content: "account sufficient ",
                                                                                                                              },
                                                                                                                              Expression {
                                                                                                                               expression: Variable {
                                                                                                                                identifier: "pam_ldap",
                                                                                                                                position: (448, 34),
                                                                                                                               },
                                                                                                                              },
                                                                                                                              Raw {
                                                                                                                               content: "/lib/security/pam_ldap.so\n",
                                                                                                                              },
                                                                                                                             ],
                                                                                                                             position: (447, 35),
                                                                                                                            },
                                                                                                                           ],
                                                                                                                          },
                                                                                                                         ],
                                                                                                                         position: (446, 14),
                                                                                                                        },
                                                                                                                        FunctionApplication {
                                                                                                                         function: Variable {
                                                                                                                          identifier: "optionalString",
                                                                                                                          position: (450, 11),
                                                                                                                         },
                                                                                                                         arguments: [
                                                                                                                          BinaryOperation {
                                                                                                                           operator: LogicalAnd,
                                                                                                                           operands: [
                                                                                                                            PropertyAccess {
                                                                                                                             expression: Variable {
                                                                                                                              identifier: "config",
                                                                                                                              position: (450, 27),
                                                                                                                             },
                                                                                                                             attribute_path: AttributePath {
                                                                                                                              attributes: [
                                                                                                                               Raw {
                                                                                                                                content: "services",
                                                                                                                                position: (450, 34),
                                                                                                                               },
                                                                                                                               Raw {
                                                                                                                                content: "sssd",
                                                                                                                                position: (450, 43),
                                                                                                                               },
                                                                                                                               Raw {
                                                                                                                                content: "enable",
                                                                                                                                position: (450, 48),
                                                                                                                               },
                                                                                                                              ],
                                                                                                                             },
                                                                                                                             default: None,
                                                                                                                            },
                                                                                                                            BinaryOperation {
                                                                                                                             operator: EqualTo,
                                                                                                                             operands: [
                                                                                                                              PropertyAccess {
                                                                                                                               expression: Variable {
                                                                                                                                identifier: "cfg",
                                                                                                                                position: (450, 58),
                                                                                                                               },
                                                                                                                               attribute_path: AttributePath {
                                                                                                                                attributes: [
                                                                                                                                 Raw {
                                                                                                                                  content: "sssdStrictAccess",
                                                                                                                                  position: (450, 62),
                                                                                                                                 },
                                                                                                                                ],
                                                                                                                               },
                                                                                                                               default: None,
                                                                                                                              },
                                                                                                                              Variable {
                                                                                                                               identifier: "false",
                                                                                                                               position: (450, 80),
                                                                                                                              },
                                                                                                                             ],
                                                                                                                             position: (450, 78),
                                                                                                                            },
                                                                                                                           ],
                                                                                                                           position: (450, 55),
                                                                                                                          },
                                                                                                                          String {
                                                                                                                           parts: [
                                                                                                                            Raw {
                                                                                                                             content: "account sufficient ",
                                                                                                                            },
                                                                                                                            Expression {
                                                                                                                             expression: PropertyAccess {
                                                                                                                              expression: Variable {
                                                                                                                               identifier: "pkgs",
                                                                                                                               position: (451, 34),
                                                                                                                              },
                                                                                                                              attribute_path: AttributePath {
                                                                                                                               attributes: [
                                                                                                                                Raw {
                                                                                                                                 content: "sssd",
                                                                                                                                 position: (451, 39),
                                                                                                                                },
                                                                                                                               ],
                                                                                                                              },
                                                                                                                              default: None,
                                                                                                                             },
                                                                                                                            },
                                                                                                                            Raw {
                                                                                                                             content: "/lib/security/pam_sss.so\n",
                                                                                                                            },
                                                                                                                           ],
                                                                                                                           position: (450, 87),
                                                                                                                          },
                                                                                                                         ],
                                                                                                                        },
                                                                                                                       ],
                                                                                                                       position: (449, 14),
                                                                                                                      },
                                                                                                                      FunctionApplication {
                                                                                                                       function: Variable {
                                                                                                                        identifier: "optionalString",
                                                                                                                        position: (453, 11),
                                                                                                                       },
                                                                                                                       arguments: [
                                                                                                                        BinaryOperation {
                                                                                                                         operator: LogicalAnd,
                                                                                                                         operands: [
                                                                                                                          PropertyAccess {
                                                                                                                           expression: Variable {
                                                                                                                            identifier: "config",
                                                                                                                            position: (453, 27),
                                                                                                                           },
                                                                                                                           attribute_path: AttributePath {
                                                                                                                            attributes: [
                                                                                                                             Raw {
                                                                                                                              content: "services",
                                                                                                                              position: (453, 34),
                                                                                                                             },
                                                                                                                             Raw {
                                                                                                                              content: "sssd",
                                                                                                                              position: (453, 43),
                                                                                                                             },
                                                                                                                             Raw {
                                                                                                                              content: "enable",
                                                                                                                              position: (453, 48),
                                                                                                                             },
                                                                                                                            ],
                                                                                                                           },
                                                                                                                           default: None,
                                                                                                                          },
                                                                                                                          PropertyAccess {
                                                                                                                           expression: Variable {
                                                                                                                            identifier: "cfg",
                                                                                                                            position: (453, 58),
                                                                                                                           },
                                                                                                                           attribute_path: AttributePath {
                                                                                                                            attributes: [
                                                                                                                             Raw {
                                                                                                                              content: "sssdStrictAccess",
                                                                                                                              position: (453, 62),
                                                                                                                             },
                                                                                                                            ],
                                                                                                                           },
                                                                                                                           default: None,
                                                                                                                          },
                                                                                                                         ],
                                                                                                                         position: (453, 55),
                                                                                                                        },
                                                                                                                        String {
                                                                                                                         parts: [
                                                                                                                          Raw {
                                                                                                                           content: "account [default=bad success=ok user_unknown=ignore] ",
                                                                                                                          },
                                                                                                                          Expression {
                                                                                                                           expression: PropertyAccess {
                                                                                                                            expression: Variable {
                                                                                                                             identifier: "pkgs",
                                                                                                                             position: (454, 68),
                                                                                                                            },
                                                                                                                            attribute_path: AttributePath {
                                                                                                                             attributes: [
                                                                                                                              Raw {
                                                                                                                               content: "sssd",
                                                                                                                               position: (454, 73),
                                                                                                                              },
                                                                                                                             ],
                                                                                                                            },
                                                                                                                            default: None,
                                                                                                                           },
                                                                                                                          },
                                                                                                                          Raw {
                                                                                                                           content: "/lib/security/pam_sss.so\n",
                                                                                                                          },
                                                                                                                         ],
                                                                                                                         position: (453, 80),
                                                                                                                        },
                                                                                                                       ],
                                                                                                                      },
                                                                                                                     ],
                                                                                                                     position: (452, 14),
                                                                                                                    },
                                                                                                                    FunctionApplication {
                                                                                                                     function: Variable {
                                                                                                                      identifier: "optionalString",
                                                                                                                      position: (456, 11),
                                                                                                                     },
                                                                                                                     arguments: [
                                                                                                                      PropertyAccess {
                                                                                                                       expression: Variable {
                                                                                                                        identifier: "config",
                                                                                                                        position: (456, 26),
                                                                                                                       },
                                                                                                                       attribute_path: AttributePath {
                                                                                                                        attributes: [
                                                                                                                         Raw {
                                                                                                                          content: "krb5",
                                                                                                                          position: (456, 33),
                                                                                                                         },
                                                                                                                         Raw {
                                                                                                                          content: "enable",
                                                                                                                          position: (456, 38),
                                                                                                                         },
                                                                                                                        ],
                                                                                                                       },
                                                                                                                       default: None,
                                                                                                                      },
                                                                                                                      String {
                                                                                                                       parts: [
                                                                                                                        Raw {
                                                                                                                         content: "account sufficient ",
                                                                                                                        },
                                                                                                                        Expression {
                                                                                                                         expression: Variable {
                                                                                                                          identifier: "pam_krb5",
                                                                                                                          position: (457, 34),
                                                                                                                         },
                                                                                                                        },
                                                                                                                        Raw {
                                                                                                                         content: "/lib/security/pam_krb5.so\n",
                                                                                                                        },
                                                                                                                       ],
                                                                                                                       position: (456, 45),
                                                                                                                      },
                                                                                                                     ],
                                                                                                                    },
                                                                                                                   ],
                                                                                                                   position: (455, 14),
                                                                                                                  },
                                                                                                                  FunctionApplication {
                                                                                                                   function: Variable {
                                                                                                                    identifier: "optionalString",
                                                                                                                    position: (459, 11),
                                                                                                                   },
                                                                                                                   arguments: [
                                                                                                                    PropertyAccess {
                                                                                                                     expression: Variable {
                                                                                                                      identifier: "cfg",
                                                                                                                      position: (459, 26),
                                                                                                                     },
                                                                                                                     attribute_path: AttributePath {
                                                                                                                      attributes: [
                                                                                                                       Raw {
                                                                                                                        content: "googleOsLoginAccountVerification",
                                                                                                                        position: (459, 30),
                                                                                                                       },
                                                                                                                      ],
                                                                                                                     },
                                                                                                                     default: None,
                                                                                                                    },
                                                                                                                    String {
                                                                                                                     parts: [
                                                                                                                      Raw {
                                                                                                                       content: "account [success=ok ignore=ignore default=die] ",
                                                                                                                      },
                                                                                                                      Expression {
                                                                                                                       expression: PropertyAccess {
                                                                                                                        expression: Variable {
                                                                                                                         identifier: "pkgs",
                                                                                                                         position: (460, 62),
                                                                                                                        },
                                                                                                                        attribute_path: AttributePath {
                                                                                                                         attributes: [
                                                                                                                          Raw {
                                                                                                                           content: "google-guest-oslogin",
                                                                                                                           position: (460, 67),
                                                                                                                          },
                                                                                                                         ],
                                                                                                                        },
                                                                                                                        default: None,
                                                                                                                       },
                                                                                                                      },
                                                                                                                      Raw {
                                                                                                                       content: "/lib/security/pam_oslogin_login.so\naccount [success=ok default=ignore] ",
                                                                                                                      },
                                                                                                                      Expression {
                                                                                                                       expression: PropertyAccess {
                                                                                                                        expression: Variable {
                                                                                                                         identifier: "pkgs",
                                                                                                                         position: (461, 51),
                                                                                                                        },
                                                                                                                        attribute_path: AttributePath {
                                                                                                                         attributes: [
                                                                                                                          Raw {
                                                                                                                           content: "google-guest-oslogin",
                                                                                                                           position: (461, 56),
                                                                                                                          },
                                                                                                                         ],
                                                                                                                        },
                                                                                                                        default: None,
                                                                                                                       },
                                                                                                                      },
                                                                                                                      Raw {
                                                                                                                       content: "/lib/security/pam_oslogin_admin.so\n",
                                                                                                                      },
                                                                                                                     ],
                                                                                                                     position: (459, 63),
                                                                                                                    },
                                                                                                                   ],
                                                                                                                  },
                                                                                                                 ],
                                                                                                                 position: (458, 14),
                                                                                                                },
                                                                                                                String {
                                                                                                                 parts: [
                                                                                                                  Raw {
                                                                                                                   content: "\n# Authentication management.\n",
                                                                                                                  },
                                                                                                                 ],
                                                                                                                 position: (463, 11),
                                                                                                                },
                                                                                                               ],
                                                                                                               position: (462, 14),
                                                                                                              },
                                                                                                              FunctionApplication {
                                                                                                               function: Variable {
                                                                                                                identifier: "optionalString",
                                                                                                                position: (467, 11),
                                                                                                               },
                                                                                                               arguments: [
                                                                                                                PropertyAccess {
                                                                                                                 expression: Variable {
                                                                                                                  identifier: "cfg",
                                                                                                                  position: (467, 26),
                                                                                                                 },
                                                                                                                 attribute_path: AttributePath {
                                                                                                                  attributes: [
                                                                                                                   Raw {
                                                                                                                    content: "googleOsLoginAuthentication",
                                                                                                                    position: (467, 30),
                                                                                                                   },
                                                                                                                  ],
                                                                                                                 },
                                                                                                                 default: None,
                                                                                                                },
                                                                                                                String {
                                                                                                                 parts: [
                                                                                                                  Raw {
                                                                                                                   content: "auth [success=done perm_denied=die default=ignore] ",
                                                                                                                  },
                                                                                                                  Expression {
                                                                                                                   expression: PropertyAccess {
                                                                                                                    expression: Variable {
                                                                                                                     identifier: "pkgs",
                                                                                                                     position: (468, 66),
                                                                                                                    },
                                                                                                                    attribute_path: AttributePath {
                                                                                                                     attributes: [
                                                                                                                      Raw {
                                                                                                                       content: "google-guest-oslogin",
                                                                                                                       position: (468, 71),
                                                                                                                      },
                                                                                                                     ],
                                                                                                                    },
                                                                                                                    default: None,
                                                                                                                   },
                                                                                                                  },
                                                                                                                  Raw {
                                                                                                                   content: "/lib/security/pam_oslogin_login.so\n",
                                                                                                                  },
                                                                                                                 ],
                                                                                                                 position: (467, 58),
                                                                                                                },
                                                                                                               ],
                                                                                                              },
                                                                                                             ],
                                                                                                             position: (466, 14),
                                                                                                            },
                                                                                                            FunctionApplication {
                                                                                                             function: Variable {
                                                                                                              identifier: "optionalString",
                                                                                                              position: (470, 11),
                                                                                                             },
                                                                                                             arguments: [
                                                                                                              PropertyAccess {
                                                                                                               expression: Variable {
                                                                                                                identifier: "cfg",
                                                                                                                position: (470, 26),
                                                                                                               },
                                                                                                               attribute_path: AttributePath {
                                                                                                                attributes: [
                                                                                                                 Raw {
                                                                                                                  content: "rootOK",
                                                                                                                  position: (470, 30),
                                                                                                                 },
                                                                                                                ],
                                                                                                               },
                                                                                                               default: None,
                                                                                                              },
                                                                                                              String {
                                                                                                               parts: [
                                                                                                                Raw {
                                                                                                                 content: "auth sufficient pam_rootok.so\n",
                                                                                                                },
                                                                                                               ],
                                                                                                               position: (470, 37),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (469, 14),
                                                                                                          },
                                                                                                          FunctionApplication {
                                                                                                           function: Variable {
                                                                                                            identifier: "optionalString",
                                                                                                            position: (473, 11),
                                                                                                           },
                                                                                                           arguments: [
                                                                                                            PropertyAccess {
                                                                                                             expression: Variable {
                                                                                                              identifier: "cfg",
                                                                                                              position: (473, 26),
                                                                                                             },
                                                                                                             attribute_path: AttributePath {
                                                                                                              attributes: [
                                                                                                               Raw {
                                                                                                                content: "requireWheel",
                                                                                                                position: (473, 30),
                                                                                                               },
                                                                                                              ],
                                                                                                             },
                                                                                                             default: None,
                                                                                                            },
                                                                                                            String {
                                                                                                             parts: [
                                                                                                              Raw {
                                                                                                               content: "auth required pam_wheel.so use_uid\n",
                                                                                                              },
                                                                                                             ],
                                                                                                             position: (473, 43),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (472, 14),
                                                                                                        },
                                                                                                        FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (476, 11),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "cfg",
                                                                                                            position: (476, 26),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "logFailures",
                                                                                                              position: (476, 30),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "auth required pam_faillock.so\n",
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (476, 42),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (475, 14),
                                                                                                      },
                                                                                                      FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (479, 11),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        BinaryOperation {
                                                                                                         operator: LogicalAnd,
                                                                                                         operands: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "config",
                                                                                                            position: (479, 27),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "security",
                                                                                                              position: (479, 34),
                                                                                                             },
                                                                                                             Raw {
                                                                                                              content: "pam",
                                                                                                              position: (479, 43),
                                                                                                             },
                                                                                                             Raw {
                                                                                                              content: "enableSSHAgentAuth",
                                                                                                              position: (479, 47),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "cfg",
                                                                                                            position: (479, 69),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "sshAgentAuth",
                                                                                                              position: (479, 73),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (479, 66),
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "auth sufficient ",
                                                                                                          },
                                                                                                          Expression {
                                                                                                           expression: PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "pkgs",
                                                                                                             position: (480, 31),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "pam_ssh_agent_auth",
                                                                                                               position: (480, 36),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "/libexec/pam_ssh_agent_auth.so file=",
                                                                                                          },
                                                                                                          Expression {
                                                                                                           expression: FunctionApplication {
                                                                                                            function: PropertyAccess {
                                                                                                             expression: Variable {
                                                                                                              identifier: "lib",
                                                                                                              position: (480, 93),
                                                                                                             },
                                                                                                             attribute_path: AttributePath {
                                                                                                              attributes: [
                                                                                                               Raw {
                                                                                                                content: "concatStringsSep",
                                                                                                                position: (480, 97),
                                                                                                               },
                                                                                                              ],
                                                                                                             },
                                                                                                             default: None,
                                                                                                            },
                                                                                                            arguments: [
                                                                                                             String {
                                                                                                              parts: [
                                                                                                               Raw {
                                                                                                                content: ":",
                                                                                                               },
                                                                                                              ],
                                                                                                              position: (480, 114),
                                                                                                             },
                                                                                                             PropertyAccess {
                                                                                                              expression: Variable {
                                                                                                               identifier: "config",
                                                                                                               position: (480, 118),
                                                                                                              },
                                                                                                              attribute_path: AttributePath {
                                                                                                               attributes: [
                                                                                                                Raw {
                                                                                                                 content: "services",
                                                                                                                 position: (480, 125),
                                                                                                                },
                                                                                                                Raw {
                                                                                                                 content: "openssh",
                                                                                                                 position: (480, 134),
                                                                                                                },
                                                                                                                Raw {
                                                                                                                 content: "authorizedKeysFiles",
                                                                                                                 position: (480, 142),
                                                                                                                },
                                                                                                               ],
                                                                                                              },
                                                                                                              default: None,
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "\n",
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (479, 87),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (478, 14),
                                                                                                    },
                                                                                                    LetIn {
                                                                                                     bindings: [
                                                                                                      KeyValue(
                                                                                                       AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "p11",
                                                                                                          position: (482, 16),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "config",
                                                                                                         position: (482, 22),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "security",
                                                                                                           position: (482, 29),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "pam",
                                                                                                           position: (482, 38),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "p11",
                                                                                                           position: (482, 42),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      ),
                                                                                                     ],
                                                                                                     target: FunctionApplication {
                                                                                                      function: Variable {
                                                                                                       identifier: "optionalString",
                                                                                                       position: (482, 50),
                                                                                                      },
                                                                                                      arguments: [
                                                                                                       PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "cfg",
                                                                                                         position: (482, 65),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "p11Auth",
                                                                                                           position: (482, 69),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                       String {
                                                                                                        parts: [
                                                                                                         Raw {
                                                                                                          content: "auth ",
                                                                                                         },
                                                                                                         Expression {
                                                                                                          expression: PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "p11",
                                                                                                            position: (483, 20),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "control",
                                                                                                              position: (483, 24),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: " ",
                                                                                                         },
                                                                                                         Expression {
                                                                                                          expression: PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "pkgs",
                                                                                                            position: (483, 35),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "pam_p11",
                                                                                                              position: (483, 40),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: "/lib/security/pam_p11.so ",
                                                                                                         },
                                                                                                         Expression {
                                                                                                          expression: PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "pkgs",
                                                                                                            position: (483, 75),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "opensc",
                                                                                                              position: (483, 80),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: "/lib/opensc-pkcs11.so\n",
                                                                                                         },
                                                                                                        ],
                                                                                                        position: (482, 77),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     position: (482, 12),
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (481, 14),
                                                                                                  },
                                                                                                  LetIn {
                                                                                                   bindings: [
                                                                                                    KeyValue(
                                                                                                     AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "u2f",
                                                                                                        position: (485, 16),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "config",
                                                                                                       position: (485, 22),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "security",
                                                                                                         position: (485, 29),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "pam",
                                                                                                         position: (485, 38),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "u2f",
                                                                                                         position: (485, 42),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    ),
                                                                                                   ],
                                                                                                   target: FunctionApplication {
                                                                                                    function: Variable {
                                                                                                     identifier: "optionalString",
                                                                                                     position: (485, 50),
                                                                                                    },
                                                                                                    arguments: [
                                                                                                     PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "cfg",
                                                                                                       position: (485, 65),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "u2fAuth",
                                                                                                         position: (485, 69),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                     String {
                                                                                                      parts: [
                                                                                                       Raw {
                                                                                                        content: "auth ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "u2f",
                                                                                                          position: (486, 20),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "control",
                                                                                                            position: (486, 24),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: " ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "pkgs",
                                                                                                          position: (486, 35),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "pam_u2f",
                                                                                                            position: (486, 40),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: "/lib/security/pam_u2f.so ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (486, 75),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "u2f",
                                                                                                            position: (486, 90),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "debug",
                                                                                                              position: (486, 94),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "debug",
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 100),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: " ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (486, 111),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          BinaryOperation {
                                                                                                           operator: NotEqualTo,
                                                                                                           operands: [
                                                                                                            PropertyAccess {
                                                                                                             expression: Variable {
                                                                                                              identifier: "u2f",
                                                                                                              position: (486, 127),
                                                                                                             },
                                                                                                             attribute_path: AttributePath {
                                                                                                              attributes: [
                                                                                                               Raw {
                                                                                                                content: "authFile",
                                                                                                                position: (486, 131),
                                                                                                               },
                                                                                                              ],
                                                                                                             },
                                                                                                             default: None,
                                                                                                            },
                                                                                                            Variable {
                                                                                                             identifier: "null",
                                                                                                             position: (486, 143),
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 140),
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "authfile=",
                                                                                                            },
                                                                                                            Expression {
                                                                                                             expression: PropertyAccess {
                                                                                                              expression: Variable {
                                                                                                               identifier: "u2f",
                                                                                                               position: (486, 161),
                                                                                                              },
                                                                                                              attribute_path: AttributePath {
                                                                                                               attributes: [
                                                                                                                Raw {
                                                                                                                 content: "authFile",
                                                                                                                 position: (486, 165),
                                                                                                                },
                                                                                                               ],
                                                                                                              },
                                                                                                              default: None,
                                                                                                             },
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 149),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: " ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (486, 179),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "u2f",
                                                                                                            position: (486, 194),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "interactive",
                                                                                                              position: (486, 198),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "interactive",
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 210),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: " ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (486, 227),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          PropertyAccess {
                                                                                                           expression: Variable {
                                                                                                            identifier: "u2f",
                                                                                                            position: (486, 242),
                                                                                                           },
                                                                                                           attribute_path: AttributePath {
                                                                                                            attributes: [
                                                                                                             Raw {
                                                                                                              content: "cue",
                                                                                                              position: (486, 246),
                                                                                                             },
                                                                                                            ],
                                                                                                           },
                                                                                                           default: None,
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "cue",
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 250),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: " ",
                                                                                                       },
                                                                                                       Expression {
                                                                                                        expression: FunctionApplication {
                                                                                                         function: Variable {
                                                                                                          identifier: "optionalString",
                                                                                                          position: (486, 259),
                                                                                                         },
                                                                                                         arguments: [
                                                                                                          BinaryOperation {
                                                                                                           operator: NotEqualTo,
                                                                                                           operands: [
                                                                                                            PropertyAccess {
                                                                                                             expression: Variable {
                                                                                                              identifier: "u2f",
                                                                                                              position: (486, 275),
                                                                                                             },
                                                                                                             attribute_path: AttributePath {
                                                                                                              attributes: [
                                                                                                               Raw {
                                                                                                                content: "appId",
                                                                                                                position: (486, 279),
                                                                                                               },
                                                                                                              ],
                                                                                                             },
                                                                                                             default: None,
                                                                                                            },
                                                                                                            Variable {
                                                                                                             identifier: "null",
                                                                                                             position: (486, 288),
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 285),
                                                                                                          },
                                                                                                          String {
                                                                                                           parts: [
                                                                                                            Raw {
                                                                                                             content: "appid=",
                                                                                                            },
                                                                                                            Expression {
                                                                                                             expression: PropertyAccess {
                                                                                                              expression: Variable {
                                                                                                               identifier: "u2f",
                                                                                                               position: (486, 303),
                                                                                                              },
                                                                                                              attribute_path: AttributePath {
                                                                                                               attributes: [
                                                                                                                Raw {
                                                                                                                 content: "appId",
                                                                                                                 position: (486, 307),
                                                                                                                },
                                                                                                               ],
                                                                                                              },
                                                                                                              default: None,
                                                                                                             },
                                                                                                            },
                                                                                                           ],
                                                                                                           position: (486, 294),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                       },
                                                                                                       Raw {
                                                                                                        content: "\n",
                                                                                                       },
                                                                                                      ],
                                                                                                      position: (485, 77),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   position: (485, 12),
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (484, 15),
                                                                                                },
                                                                                                FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (488, 11),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "cfg",
                                                                                                    position: (488, 26),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "usbAuth",
                                                                                                      position: (488, 30),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "auth sufficient ",
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "pkgs",
                                                                                                       position: (489, 31),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "pam_usb",
                                                                                                         position: (489, 36),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    },
                                                                                                    Raw {
                                                                                                     content: "/lib/security/pam_usb.so\n",
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (488, 38),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               ],
                                                                                               position: (487, 15),
                                                                                              },
                                                                                              LetIn {
                                                                                               bindings: [
                                                                                                KeyValue(
                                                                                                 AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "ussh",
                                                                                                    position: (491, 16),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 PropertyAccess {
                                                                                                  expression: Variable {
                                                                                                   identifier: "config",
                                                                                                   position: (491, 23),
                                                                                                  },
                                                                                                  attribute_path: AttributePath {
                                                                                                   attributes: [
                                                                                                    Raw {
                                                                                                     content: "security",
                                                                                                     position: (491, 30),
                                                                                                    },
                                                                                                    Raw {
                                                                                                     content: "pam",
                                                                                                     position: (491, 39),
                                                                                                    },
                                                                                                    Raw {
                                                                                                     content: "ussh",
                                                                                                     position: (491, 43),
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                  default: None,
                                                                                                 },
                                                                                                ),
                                                                                               ],
                                                                                               target: FunctionApplication {
                                                                                                function: Variable {
                                                                                                 identifier: "optionalString",
                                                                                                 position: (491, 52),
                                                                                                },
                                                                                                arguments: [
                                                                                                 BinaryOperation {
                                                                                                  operator: LogicalAnd,
                                                                                                  operands: [
                                                                                                   PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "config",
                                                                                                     position: (491, 68),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "security",
                                                                                                       position: (491, 75),
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "pam",
                                                                                                       position: (491, 84),
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "ussh",
                                                                                                       position: (491, 88),
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "enable",
                                                                                                       position: (491, 93),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                   PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "cfg",
                                                                                                     position: (491, 103),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "usshAuth",
                                                                                                       position: (491, 107),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                  ],
                                                                                                  position: (491, 100),
                                                                                                 },
                                                                                                 String {
                                                                                                  parts: [
                                                                                                   Raw {
                                                                                                    content: "auth ",
                                                                                                   },
                                                                                                   Expression {
                                                                                                    expression: PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "ussh",
                                                                                                      position: (492, 20),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "control",
                                                                                                        position: (492, 25),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: " ",
                                                                                                   },
                                                                                                   Expression {
                                                                                                    expression: PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "pkgs",
                                                                                                      position: (492, 36),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "pam_ussh",
                                                                                                        position: (492, 41),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: "/lib/security/pam_ussh.so ",
                                                                                                   },
                                                                                                   Expression {
                                                                                                    expression: FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (492, 78),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      BinaryOperation {
                                                                                                       operator: NotEqualTo,
                                                                                                       operands: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "ussh",
                                                                                                          position: (492, 94),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "caFile",
                                                                                                            position: (492, 99),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        Variable {
                                                                                                         identifier: "null",
                                                                                                         position: (492, 109),
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 106),
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "ca_file=",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "ussh",
                                                                                                           position: (492, 126),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "caFile",
                                                                                                             position: (492, 131),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 115),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: " ",
                                                                                                   },
                                                                                                   Expression {
                                                                                                    expression: FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (492, 143),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      BinaryOperation {
                                                                                                       operator: NotEqualTo,
                                                                                                       operands: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "ussh",
                                                                                                          position: (492, 159),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "authorizedPrincipals",
                                                                                                            position: (492, 164),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        Variable {
                                                                                                         identifier: "null",
                                                                                                         position: (492, 188),
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 185),
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "authorized_principals=",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "ussh",
                                                                                                           position: (492, 219),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "authorizedPrincipals",
                                                                                                             position: (492, 224),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 194),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: " ",
                                                                                                   },
                                                                                                   Expression {
                                                                                                    expression: FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (492, 250),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      BinaryOperation {
                                                                                                       operator: NotEqualTo,
                                                                                                       operands: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "ussh",
                                                                                                          position: (492, 266),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "authorizedPrincipalsFile",
                                                                                                            position: (492, 271),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        Variable {
                                                                                                         identifier: "null",
                                                                                                         position: (492, 299),
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 296),
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "authorized_principals_file=",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "ussh",
                                                                                                           position: (492, 335),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "authorizedPrincipalsFile",
                                                                                                             position: (492, 340),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 305),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: " ",
                                                                                                   },
                                                                                                   Expression {
                                                                                                    expression: FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (492, 370),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      BinaryOperation {
                                                                                                       operator: NotEqualTo,
                                                                                                       operands: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "ussh",
                                                                                                          position: (492, 386),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "group",
                                                                                                            position: (492, 391),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        Variable {
                                                                                                         identifier: "null",
                                                                                                         position: (492, 400),
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 397),
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "group=",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "ussh",
                                                                                                           position: (492, 415),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "group",
                                                                                                             position: (492, 420),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (492, 406),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: "\n",
                                                                                                   },
                                                                                                  ],
                                                                                                  position: (491, 117),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               position: (491, 12),
                                                                                              },
                                                                                             ],
                                                                                             position: (490, 14),
                                                                                            },
                                                                                            LetIn {
                                                                                             bindings: [
                                                                                              KeyValue(
                                                                                               AttributePath {
                                                                                                attributes: [
                                                                                                 Raw {
                                                                                                  content: "oath",
                                                                                                  position: (494, 16),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               PropertyAccess {
                                                                                                expression: Variable {
                                                                                                 identifier: "config",
                                                                                                 position: (494, 23),
                                                                                                },
                                                                                                attribute_path: AttributePath {
                                                                                                 attributes: [
                                                                                                  Raw {
                                                                                                   content: "security",
                                                                                                   position: (494, 30),
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "pam",
                                                                                                   position: (494, 39),
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "oath",
                                                                                                   position: (494, 43),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                                default: None,
                                                                                               },
                                                                                              ),
                                                                                             ],
                                                                                             target: FunctionApplication {
                                                                                              function: Variable {
                                                                                               identifier: "optionalString",
                                                                                               position: (494, 52),
                                                                                              },
                                                                                              arguments: [
                                                                                               PropertyAccess {
                                                                                                expression: Variable {
                                                                                                 identifier: "cfg",
                                                                                                 position: (494, 67),
                                                                                                },
                                                                                                attribute_path: AttributePath {
                                                                                                 attributes: [
                                                                                                  Raw {
                                                                                                   content: "oathAuth",
                                                                                                   position: (494, 71),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                                default: None,
                                                                                               },
                                                                                               String {
                                                                                                parts: [
                                                                                                 Raw {
                                                                                                  content: "auth requisite ",
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "pkgs",
                                                                                                    position: (495, 30),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "oathToolkit",
                                                                                                      position: (495, 35),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "/lib/security/pam_oath.so window=",
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "toString",
                                                                                                    position: (495, 82),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "oath",
                                                                                                      position: (495, 91),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "window",
                                                                                                        position: (495, 96),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: " usersfile=",
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "toString",
                                                                                                    position: (495, 116),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "oath",
                                                                                                      position: (495, 125),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "usersFile",
                                                                                                        position: (495, 130),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: " digits=",
                                                                                                 },
                                                                                                 Expression {
                                                                                                  expression: FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "toString",
                                                                                                    position: (495, 150),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "oath",
                                                                                                      position: (495, 159),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "digits",
                                                                                                        position: (495, 164),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "\n",
                                                                                                 },
                                                                                                ],
                                                                                                position: (494, 80),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             position: (494, 12),
                                                                                            },
                                                                                           ],
                                                                                           position: (493, 15),
                                                                                          },
                                                                                          LetIn {
                                                                                           bindings: [
                                                                                            KeyValue(
                                                                                             AttributePath {
                                                                                              attributes: [
                                                                                               Raw {
                                                                                                content: "yubi",
                                                                                                position: (497, 16),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             PropertyAccess {
                                                                                              expression: Variable {
                                                                                               identifier: "config",
                                                                                               position: (497, 23),
                                                                                              },
                                                                                              attribute_path: AttributePath {
                                                                                               attributes: [
                                                                                                Raw {
                                                                                                 content: "security",
                                                                                                 position: (497, 30),
                                                                                                },
                                                                                                Raw {
                                                                                                 content: "pam",
                                                                                                 position: (497, 39),
                                                                                                },
                                                                                                Raw {
                                                                                                 content: "yubico",
                                                                                                 position: (497, 43),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                              default: None,
                                                                                             },
                                                                                            ),
                                                                                           ],
                                                                                           target: FunctionApplication {
                                                                                            function: Variable {
                                                                                             identifier: "optionalString",
                                                                                             position: (497, 54),
                                                                                            },
                                                                                            arguments: [
                                                                                             PropertyAccess {
                                                                                              expression: Variable {
                                                                                               identifier: "cfg",
                                                                                               position: (497, 69),
                                                                                              },
                                                                                              attribute_path: AttributePath {
                                                                                               attributes: [
                                                                                                Raw {
                                                                                                 content: "yubicoAuth",
                                                                                                 position: (497, 73),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                              default: None,
                                                                                             },
                                                                                             String {
                                                                                              parts: [
                                                                                               Raw {
                                                                                                content: "auth ",
                                                                                               },
                                                                                               Expression {
                                                                                                expression: PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "yubi",
                                                                                                  position: (498, 20),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "control",
                                                                                                    position: (498, 25),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                               },
                                                                                               Expression {
                                                                                                expression: PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "pkgs",
                                                                                                  position: (498, 36),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "yubico-pam",
                                                                                                    position: (498, 41),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: "/lib/security/pam_yubico.so mode=",
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "toString",
                                                                                                  position: (498, 87),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "yubi",
                                                                                                    position: (498, 96),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "mode",
                                                                                                      position: (498, 101),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (498, 109),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  BinaryOperation {
                                                                                                   operator: NotEqualTo,
                                                                                                   operands: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "yubi",
                                                                                                      position: (498, 125),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "challengeResponsePath",
                                                                                                        position: (498, 130),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                    Variable {
                                                                                                     identifier: "null",
                                                                                                     position: (498, 155),
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (498, 152),
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "chalresp_path=",
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "yubi",
                                                                                                       position: (498, 178),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "challengeResponsePath",
                                                                                                         position: (498, 183),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (498, 161),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (498, 210),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  BinaryOperation {
                                                                                                   operator: EqualTo,
                                                                                                   operands: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "yubi",
                                                                                                      position: (498, 226),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "mode",
                                                                                                        position: (498, 231),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                    String {
                                                                                                     parts: [
                                                                                                      Raw {
                                                                                                       content: "client",
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (498, 239),
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (498, 236),
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "id=",
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: FunctionApplication {
                                                                                                      function: Variable {
                                                                                                       identifier: "toString",
                                                                                                       position: (498, 255),
                                                                                                      },
                                                                                                      arguments: [
                                                                                                       PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "yubi",
                                                                                                         position: (498, 264),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "id",
                                                                                                           position: (498, 269),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (498, 249),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: " ",
                                                                                               },
                                                                                               Expression {
                                                                                                expression: FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (498, 277),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "yubi",
                                                                                                    position: (498, 292),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "debug",
                                                                                                      position: (498, 297),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "debug",
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (498, 303),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               },
                                                                                               Raw {
                                                                                                content: "\n",
                                                                                               },
                                                                                              ],
                                                                                              position: (497, 84),
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                           position: (497, 12),
                                                                                          },
                                                                                         ],
                                                                                         position: (496, 15),
                                                                                        },
                                                                                        FunctionApplication {
                                                                                         function: Variable {
                                                                                          identifier: "optionalString",
                                                                                          position: (500, 11),
                                                                                         },
                                                                                         arguments: [
                                                                                          PropertyAccess {
                                                                                           expression: Variable {
                                                                                            identifier: "cfg",
                                                                                            position: (500, 26),
                                                                                           },
                                                                                           attribute_path: AttributePath {
                                                                                            attributes: [
                                                                                             Raw {
                                                                                              content: "fprintAuth",
                                                                                              position: (500, 30),
                                                                                             },
                                                                                            ],
                                                                                           },
                                                                                           default: None,
                                                                                          },
                                                                                          String {
                                                                                           parts: [
                                                                                            Raw {
                                                                                             content: "auth sufficient ",
                                                                                            },
                                                                                            Expression {
                                                                                             expression: PropertyAccess {
                                                                                              expression: Variable {
                                                                                               identifier: "pkgs",
                                                                                               position: (501, 31),
                                                                                              },
                                                                                              attribute_path: AttributePath {
                                                                                               attributes: [
                                                                                                Raw {
                                                                                                 content: "fprintd",
                                                                                                 position: (501, 36),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                              default: None,
                                                                                             },
                                                                                            },
                                                                                            Raw {
                                                                                             content: "/lib/security/pam_fprintd.so\n",
                                                                                            },
                                                                                           ],
                                                                                           position: (500, 41),
                                                                                          },
                                                                                         ],
                                                                                        },
                                                                                       ],
                                                                                       position: (499, 15),
                                                                                      },
                                                                                      FunctionApplication {
                                                                                       function: Variable {
                                                                                        identifier: "optionalString",
                                                                                        position: (509, 12),
                                                                                       },
                                                                                       arguments: [
                                                                                        BinaryOperation {
                                                                                         operator: LogicalAnd,
                                                                                         operands: [
                                                                                          PropertyAccess {
                                                                                           expression: Variable {
                                                                                            identifier: "cfg",
                                                                                            position: (509, 28),
                                                                                           },
                                                                                           attribute_path: AttributePath {
                                                                                            attributes: [
                                                                                             Raw {
                                                                                              content: "unixAuth",
                                                                                              position: (509, 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: (510, 14),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "security",
                                                                                                          position: (510, 21),
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: "pam",
                                                                                                          position: (510, 30),
                                                                                                         },
                                                                                                         Raw {
                                                                                                          content: "enableEcryptfs",
                                                                                                          position: (510, 34),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                      PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "cfg",
                                                                                                        position: (511, 18),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "pamMount",
                                                                                                          position: (511, 22),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (511, 15),
                                                                                                    },
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "cfg",
                                                                                                      position: (512, 18),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "enableKwallet",
                                                                                                        position: (512, 22),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (512, 15),
                                                                                                  },
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "cfg",
                                                                                                    position: (513, 18),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "enableGnomeKeyring",
                                                                                                      position: (513, 22),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (513, 15),
                                                                                                },
                                                                                                PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "cfg",
                                                                                                  position: (514, 18),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "googleAuthenticator",
                                                                                                    position: (514, 22),
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: "enable",
                                                                                                    position: (514, 42),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                               ],
                                                                                               position: (514, 15),
                                                                                              },
                                                                                              PropertyAccess {
                                                                                               expression: Variable {
                                                                                                identifier: "cfg",
                                                                                                position: (515, 18),
                                                                                               },
                                                                                               attribute_path: AttributePath {
                                                                                                attributes: [
                                                                                                 Raw {
                                                                                                  content: "gnupg",
                                                                                                  position: (515, 22),
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "enable",
                                                                                                  position: (515, 28),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               default: None,
                                                                                              },
                                                                                             ],
                                                                                             position: (515, 15),
                                                                                            },
                                                                                            PropertyAccess {
                                                                                             expression: Variable {
                                                                                              identifier: "cfg",
                                                                                              position: (516, 18),
                                                                                             },
                                                                                             attribute_path: AttributePath {
                                                                                              attributes: [
                                                                                               Raw {
                                                                                                content: "duoSecurity",
                                                                                                position: (516, 22),
                                                                                               },
                                                                                               Raw {
                                                                                                content: "enable",
                                                                                                position: (516, 34),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             default: None,
                                                                                            },
                                                                                           ],
                                                                                           position: (516, 15),
                                                                                          },
                                                                                         ],
                                                                                         position: (509, 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 ",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: FunctionApplication {
                                                                                                          function: Variable {
                                                                                                           identifier: "optionalString",
                                                                                                           position: (519, 45),
                                                                                                          },
                                                                                                          arguments: [
                                                                                                           PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "cfg",
                                                                                                             position: (519, 60),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "allowNullPassword",
                                                                                                               position: (519, 64),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                           String {
                                                                                                            parts: [
                                                                                                             Raw {
                                                                                                              content: "nullok",
                                                                                                             },
                                                                                                            ],
                                                                                                            position: (519, 82),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: " ",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: FunctionApplication {
                                                                                                          function: Variable {
                                                                                                           identifier: "optionalString",
                                                                                                           position: (519, 94),
                                                                                                          },
                                                                                                          arguments: [
                                                                                                           PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "cfg",
                                                                                                             position: (519, 109),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "nodelay",
                                                                                                               position: (519, 113),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                           String {
                                                                                                            parts: [
                                                                                                             Raw {
                                                                                                              content: "nodelay",
                                                                                                             },
                                                                                                            ],
                                                                                                            position: (519, 121),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: " likeauth\n",
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (518, 15),
                                                                                                      },
                                                                                                      FunctionApplication {
                                                                                                       function: Variable {
                                                                                                        identifier: "optionalString",
                                                                                                        position: (521, 15),
                                                                                                       },
                                                                                                       arguments: [
                                                                                                        PropertyAccess {
                                                                                                         expression: Variable {
                                                                                                          identifier: "config",
                                                                                                          position: (521, 30),
                                                                                                         },
                                                                                                         attribute_path: AttributePath {
                                                                                                          attributes: [
                                                                                                           Raw {
                                                                                                            content: "security",
                                                                                                            position: (521, 37),
                                                                                                           },
                                                                                                           Raw {
                                                                                                            content: "pam",
                                                                                                            position: (521, 46),
                                                                                                           },
                                                                                                           Raw {
                                                                                                            content: "enableEcryptfs",
                                                                                                            position: (521, 50),
                                                                                                           },
                                                                                                          ],
                                                                                                         },
                                                                                                         default: None,
                                                                                                        },
                                                                                                        String {
                                                                                                         parts: [
                                                                                                          Raw {
                                                                                                           content: "auth optional ",
                                                                                                          },
                                                                                                          Expression {
                                                                                                           expression: PropertyAccess {
                                                                                                            expression: Variable {
                                                                                                             identifier: "pkgs",
                                                                                                             position: (522, 33),
                                                                                                            },
                                                                                                            attribute_path: AttributePath {
                                                                                                             attributes: [
                                                                                                              Raw {
                                                                                                               content: "ecryptfs",
                                                                                                               position: (522, 38),
                                                                                                              },
                                                                                                             ],
                                                                                                            },
                                                                                                            default: None,
                                                                                                           },
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "/lib/security/pam_ecryptfs.so unwrap\n",
                                                                                                          },
                                                                                                         ],
                                                                                                         position: (521, 65),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (520, 18),
                                                                                                    },
                                                                                                    FunctionApplication {
                                                                                                     function: Variable {
                                                                                                      identifier: "optionalString",
                                                                                                      position: (524, 15),
                                                                                                     },
                                                                                                     arguments: [
                                                                                                      PropertyAccess {
                                                                                                       expression: Variable {
                                                                                                        identifier: "cfg",
                                                                                                        position: (524, 30),
                                                                                                       },
                                                                                                       attribute_path: AttributePath {
                                                                                                        attributes: [
                                                                                                         Raw {
                                                                                                          content: "pamMount",
                                                                                                          position: (524, 34),
                                                                                                         },
                                                                                                        ],
                                                                                                       },
                                                                                                       default: None,
                                                                                                      },
                                                                                                      String {
                                                                                                       parts: [
                                                                                                        Raw {
                                                                                                         content: "auth optional ",
                                                                                                        },
                                                                                                        Expression {
                                                                                                         expression: PropertyAccess {
                                                                                                          expression: Variable {
                                                                                                           identifier: "pkgs",
                                                                                                           position: (525, 33),
                                                                                                          },
                                                                                                          attribute_path: AttributePath {
                                                                                                           attributes: [
                                                                                                            Raw {
                                                                                                             content: "pam_mount",
                                                                                                             position: (525, 38),
                                                                                                            },
                                                                                                           ],
                                                                                                          },
                                                                                                          default: None,
                                                                                                         },
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "/lib/security/pam_mount.so disable_interactive\n",
                                                                                                        },
                                                                                                       ],
                                                                                                       position: (524, 43),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (523, 18),
                                                                                                  },
                                                                                                  FunctionApplication {
                                                                                                   function: Variable {
                                                                                                    identifier: "optionalString",
                                                                                                    position: (527, 15),
                                                                                                   },
                                                                                                   arguments: [
                                                                                                    PropertyAccess {
                                                                                                     expression: Variable {
                                                                                                      identifier: "cfg",
                                                                                                      position: (527, 30),
                                                                                                     },
                                                                                                     attribute_path: AttributePath {
                                                                                                      attributes: [
                                                                                                       Raw {
                                                                                                        content: "enableKwallet",
                                                                                                        position: (527, 34),
                                                                                                       },
                                                                                                      ],
                                                                                                     },
                                                                                                     default: None,
                                                                                                    },
                                                                                                    String {
                                                                                                     parts: [
                                                                                                      Raw {
                                                                                                       content: "auth optional ",
                                                                                                      },
                                                                                                      Expression {
                                                                                                       expression: PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "pkgs",
                                                                                                         position: (528, 32),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "plasma5Packages",
                                                                                                           position: (528, 37),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "kwallet-pam",
                                                                                                           position: (528, 53),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "/lib/security/pam_kwallet5.so kwalletd=",
                                                                                                      },
                                                                                                      Expression {
                                                                                                       expression: PropertyAccess {
                                                                                                        expression: Variable {
                                                                                                         identifier: "pkgs",
                                                                                                         position: (528, 106),
                                                                                                        },
                                                                                                        attribute_path: AttributePath {
                                                                                                         attributes: [
                                                                                                          Raw {
                                                                                                           content: "plasma5Packages",
                                                                                                           position: (528, 111),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "kwallet",
                                                                                                           position: (528, 127),
                                                                                                          },
                                                                                                          Raw {
                                                                                                           content: "bin",
                                                                                                           position: (528, 135),
                                                                                                          },
                                                                                                         ],
                                                                                                        },
                                                                                                        default: None,
                                                                                                       },
                                                                                                      },
                                                                                                      Raw {
                                                                                                       content: "/bin/kwalletd5\n",
                                                                                                      },
                                                                                                     ],
                                                                                                     position: (527, 48),
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (526, 18),
                                                                                                },
                                                                                                FunctionApplication {
                                                                                                 function: Variable {
                                                                                                  identifier: "optionalString",
                                                                                                  position: (530, 15),
                                                                                                 },
                                                                                                 arguments: [
                                                                                                  PropertyAccess {
                                                                                                   expression: Variable {
                                                                                                    identifier: "cfg",
                                                                                                    position: (530, 30),
                                                                                                   },
                                                                                                   attribute_path: AttributePath {
                                                                                                    attributes: [
                                                                                                     Raw {
                                                                                                      content: "enableGnomeKeyring",
                                                                                                      position: (530, 34),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                   default: None,
                                                                                                  },
                                                                                                  String {
                                                                                                   parts: [
                                                                                                    Raw {
                                                                                                     content: "auth optional ",
                                                                                                    },
                                                                                                    Expression {
                                                                                                     expression: PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "pkgs",
                                                                                                       position: (531, 33),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "gnome",
                                                                                                         position: (531, 38),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "gnome-keyring",
                                                                                                         position: (531, 44),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                    },
                                                                                                    Raw {
                                                                                                     content: "/lib/security/pam_gnome_keyring.so\n",
                                                                                                    },
                                                                                                   ],
                                                                                                   position: (530, 53),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                               ],
                                                                                               position: (529, 18),
                                                                                              },
                                                                                              FunctionApplication {
                                                                                               function: Variable {
                                                                                                identifier: "optionalString",
                                                                                                position: (533, 15),
                                                                                               },
                                                                                               arguments: [
                                                                                                PropertyAccess {
                                                                                                 expression: Variable {
                                                                                                  identifier: "cfg",
                                                                                                  position: (533, 30),
                                                                                                 },
                                                                                                 attribute_path: AttributePath {
                                                                                                  attributes: [
                                                                                                   Raw {
                                                                                                    content: "gnupg",
                                                                                                    position: (533, 34),
                                                                                                   },
                                                                                                   Raw {
                                                                                                    content: "enable",
                                                                                                    position: (533, 40),
                                                                                                   },
                                                                                                  ],
                                                                                                 },
                                                                                                 default: None,
                                                                                                },
                                                                                                String {
                                                                                                 parts: [
                                                                                                  Raw {
                                                                                                   content: "auth optional ",
                                                                                                  },
                                                                                                  Expression {
                                                                                                   expression: PropertyAccess {
                                                                                                    expression: Variable {
                                                                                                     identifier: "pkgs",
                                                                                                     position: (534, 33),
                                                                                                    },
                                                                                                    attribute_path: AttributePath {
                                                                                                     attributes: [
                                                                                                      Raw {
                                                                                                       content: "pam_gnupg",
                                                                                                       position: (534, 38),
                                                                                                      },
                                                                                                     ],
                                                                                                    },
                                                                                                    default: None,
                                                                                                   },
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "/lib/security/pam_gnupg.so ",
                                                                                                  },
                                                                                                  Expression {
                                                                                                   expression: FunctionApplication {
                                                                                                    function: Variable {
                                                                                                     identifier: "optionalString",
                                                                                                     position: (534, 77),
                                                                                                    },
                                                                                                    arguments: [
                                                                                                     PropertyAccess {
                                                                                                      expression: Variable {
                                                                                                       identifier: "cfg",
                                                                                                       position: (534, 92),
                                                                                                      },
                                                                                                      attribute_path: AttributePath {
                                                                                                       attributes: [
                                                                                                        Raw {
                                                                                                         content: "gnupg",
                                                                                                         position: (534, 96),
                                                                                                        },
                                                                                                        Raw {
                                                                                                         content: "storeOnly",
                                                                                                         position: (534, 102),
                                                                                                        },
                                                                                                       ],
                                                                                                      },
                                                                                                      default: None,
                                                                                                     },
                                                                                                     String {
                                                                                                      parts: [
                                                                                                       Raw {
                                                                                                        content: " store-only",
                                                                                                       },
                                                                                                      ],
                                                                                                      position: (534, 112),
                                                                                                     },
                                                                                                    ],
                                                                                                   },
                                                                                                  },
                                                                                                  Raw {
                                                                                                   content: "\n",
                                                                                                  },
                                                                                                 ],
                                                                                                 position: (533, 47),
                                                                                                },
                                                                                               ],
                                                                                              },
                                                                                             ],
                                                                                             position: (532, 18),
                                                                                            },
                                                                                            FunctionApplication {
                                                                                             function: Variable {
                                                                                              identifier: "optionalString",
                                                                                              position: (536, 15),
                                                                                             },
                                                                                             arguments: [
                                                                                              PropertyAccess {
                                                                                               expression: Variable {
                                                                                                identifier: "cfg",
                                                                                                position: (536, 30),
                                                                                               },
                                                                                               attribute_path: AttributePath {
                                                                                                attributes: [
                                                                                                 Raw {
                                                                                                  content: "googleAuthenticator",
                                                                                                  position: (536, 34),
                                                                                                 },
                                                                                                 Raw {
                                                                                                  content: "enable",
                                                                                                  position: (536, 54),
                                                                                                 },
                                                                                                ],
                                                                                               },
                                                                                               default: None,
                                                                                              },
                                                                                              String {
                                                                                               parts: [
                                                                                                Raw {
                                                                                                 content: "auth required ",
                                                                                                },
                                                                                                Expression {
                                                                                                 expression: PropertyAccess {
                                                                                                  expression: Variable {
                                                                                                   identifier: "pkgs",
                                                                                                   position: (537, 33),
                                                                                                  },
                                                                                                  attribute_path: AttributePath {
                                                                                                   attributes: [
                                                                                                    Raw {
                                                                                                     content: "google-authenticator",
                                                                                                     position: (537, 38),
                                                                                                    },
                                                                                                   ],
                                                                                                  },
                                                                                                  default: None,
                                                                                                 },
                                                                                                },
                                                                                                Raw {
                                                                                                 content: "/lib/security/pam_google_authenticator.so no_increment_hotp\n",
                                                                                                },
                                                                                               ],
                                                                                               position: (536, 61),
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                           ],
                                                                                           position: (535, 18),
                                                                                          },
                                                                                          FunctionApplication {
                                                                                           function: Variable {
                                                                                            identifier: "optionalString",
                                                                                            position: (539, 15),
                                                                                           },
                                                                                           arguments: [
                                                                                            PropertyAccess {
                                                                                             expression: Variable {
                                                                                              identifier: "cfg",
                                                                                              position: (539, 30),
                                                                                             },
                                                                                             attribute_path: AttributePath {
                                                                                              attributes: [
                                                                                               Raw {
                                                                                                content: "duoSecurity",
                                                                                                position: (539, 34),
                                                                                               },
                                                                                               Raw {
                                                                                                content: "enable",
                                                                                                position: (539, 46),
                                                                                               },
                                                                                              ],
                                                                                             },
                                                                                             default: None,
                                                                                            },
                                                                                            String {
                                                                                             parts: [
                                                                                              Raw {
                                                                                               content: "auth required ",
                                                                                              },
                                                                                              Expression {
                                                                                               expression: PropertyAccess {
                                                                                                expression: Variable {
                                                                                                 identifier: "pkgs",
                                                                                                 position: (540, 33),
                                                                                                },
                                                                                                attribute_path: AttributePath {
                                                                                                 attributes: [
                                                                                                  Raw {
                                                                                                   content: "duo-unix",
                                                                                                   position: (540, 38),
                                                                                                  },
                                                                                                 ],
                                                                                                },
                                                                                                default: None,
                                                                                               },
                                                                                              },
                                                                                              Raw {
                                                                                               content: "/lib/security/pam_duo.so\n",
                                                                                              },
                                                                                             ],
                                                                                             position: (539, 53),
                                                                                            },
                                                                                           ],
                                                                                          },
                                                                                         ],
                                                                                         position: (538, 18),
                                                                                        },
                                                                                       ],
                                                                                      },
                                                                                     ],
                                                                                     position: (502, 14),
                                                                                    },
                                                                                    FunctionApplication {
                                                                                     function: Variable {
                                                                                      identifier: "optionalString",
                                                                                      position: (543, 11),
                                                                                     },
                                                                                     arguments: [
                                                                                      PropertyAccess {
                                                                                       expression: Variable {
                                                                                        identifier: "cfg",
                                                                                        position: (543, 26),
                                                                                       },
                                                                                       attribute_path: AttributePath {
                                                                                        attributes: [
                                                                                         Raw {
                                                                                          content: "unixAuth",
                                                                                          position: (543, 30),
                                                                                         },
                                                                                        ],
                                                                                       },
                                                                                       default: None,
                                                                                      },
                                                                                      String {
                                                                                       parts: [
                                                                                        Raw {
                                                                                         content: "auth sufficient pam_unix.so ",
                                                                                        },
                                                                                        Expression {
                                                                                         expression: FunctionApplication {
                                                                                          function: Variable {
                                                                                           identifier: "optionalString",
                                                                                           position: (544, 43),
                                                                                          },
                                                                                          arguments: [
                                                                                           PropertyAccess {
                                                                                            expression: Variable {
                                                                                             identifier: "cfg",
                                                                                             position: (544, 58),
                                                                                            },
                                                                                            attribute_path: AttributePath {
                                                                                             attributes: [
                                                                                              Raw {
                                                                                               content: "allowNullPassword",
                                                                                               position: (544, 62),
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                            default: None,
                                                                                           },
                                                                                           String {
                                                                                            parts: [
                                                                                             Raw {
                                                                                              content: "nullok",
                                                                                             },
                                                                                            ],
                                                                                            position: (544, 80),
                                                                                           },
                                                                                          ],
                                                                                         },
                                                                                        },
                                                                                        Raw {
                                                                                         content: " ",
                                                                                        },
                                                                                        Expression {
                                                                                         expression: FunctionApplication {
                                                                                          function: Variable {
                                                                                           identifier: "optionalString",
                                                                                           position: (544, 92),
                                                                                          },
                                                                                          arguments: [
                                                                                           PropertyAccess {
                                                                                            expression: Variable {
                                                                                             identifier: "cfg",
                                                                                             position: (544, 107),
                                                                                            },
                                                                                            attribute_path: AttributePath {
                                                                                             attributes: [
                                                                                              Raw {
                                                                                               content: "nodelay",
                                                                                               position: (544, 111),
                                                                                              },
                                                                                             ],
                                                                                            },
                                                                                            default: None,
                                                                                           },
                                                                                           String {
                                                                                            parts: [
                                                                                             Raw {
                                                                                              content: "nodelay",
                                                                                             },
                                                                                            ],
                                                                                            position: (544, 119),
                                                                                           },
                                                                                          ],
                                                                                         },
                                                                                        },
                                                                                        Raw {
                                                                                         content: " likeauth try_first_pass\n",
                                                                                        },
                                                                                       ],
                                                                                       position: (543, 39),
                                                                                      },
                                                                                     ],
                                                                                    },
                                                                                   ],
                                                                                   position: (542, 16),
                                                                                  },
                                                                                  FunctionApplication {
                                                                                   function: Variable {
                                                                                    identifier: "optionalString",
                                                                                    position: (546, 11),
                                                                                   },
                                                                                   arguments: [
                                                                                    PropertyAccess {
                                                                                     expression: Variable {
                                                                                      identifier: "cfg",
                                                                                      position: (546, 26),
                                                                                     },
                                                                                     attribute_path: AttributePath {
                                                                                      attributes: [
                                                                                       Raw {
                                                                                        content: "otpwAuth",
                                                                                        position: (546, 30),
                                                                                       },
                                                                                      ],
                                                                                     },
                                                                                     default: None,
                                                                                    },
                                                                                    String {
                                                                                     parts: [
                                                                                      Raw {
                                                                                       content: "auth sufficient ",
                                                                                      },
                                                                                      Expression {
                                                                                       expression: PropertyAccess {
                                                                                        expression: Variable {
                                                                                         identifier: "pkgs",
                                                                                         position: (547, 31),
                                                                                        },
                                                                                        attribute_path: AttributePath {
                                                                                         attributes: [
                                                                                          Raw {
                                                                                           content: "otpw",
                                                                                           position: (547, 36),
                                                                                          },
                                                                                         ],
                                                                                        },
                                                                                        default: None,
                                                                                       },
                                                                                      },
                                                                                      Raw {
                                                                                       content: "/lib/security/pam_otpw.so\n",
                                                                                      },
                                                                                     ],
                                                                                     position: (546, 39),
                                                                                    },
                                                                                   ],
                                                                                  },
                                                                                 ],
                                                                                 position: (545, 14),
                                                                                },
                                                                                FunctionApplication {
                                                                                 function: Variable {
                                                                                  identifier: "optionalString",
                                                                                  position: (549, 11),
                                                                                 },
                                                                                 arguments: [
                                                                                  Variable {
                                                                                   identifier: "use_ldap",
                                                                                   position: (549, 26),
                                                                                  },
                                                                                  String {
                                                                                   parts: [
                                                                                    Raw {
                                                                                     content: "auth sufficient ",
                                                                                    },
                                                                                    Expression {
                                                                                     expression: Variable {
                                                                                      identifier: "pam_ldap",
                                                                                      position: (550, 31),
                                                                                     },
                                                                                    },
                                                                                    Raw {
                                                                                     content: "/lib/security/pam_ldap.so use_first_pass\n",
                                                                                    },
                                                                                   ],
                                                                                   position: (549, 35),
                                                                                  },
                                                                                 ],
                                                                                },
                                                                               ],
                                                                               position: (548, 14),
                                                                              },
                                                                              FunctionApplication {
                                                                               function: Variable {
                                                                                identifier: "optionalString",
                                                                                position: (552, 11),
                                                                               },
                                                                               arguments: [
                                                                                PropertyAccess {
                                                                                 expression: Variable {
                                                                                  identifier: "config",
                                                                                  position: (552, 26),
                                                                                 },
                                                                                 attribute_path: AttributePath {
                                                                                  attributes: [
                                                                                   Raw {
                                                                                    content: "services",
                                                                                    position: (552, 33),
                                                                                   },
                                                                                   Raw {
                                                                                    content: "sssd",
                                                                                    position: (552, 42),
                                                                                   },
                                                                                   Raw {
                                                                                    content: "enable",
                                                                                    position: (552, 47),
                                                                                   },
                                                                                  ],
                                                                                 },
                                                                                 default: None,
                                                                                },
                                                                                String {
                                                                                 parts: [
                                                                                  Raw {
                                                                                   content: "auth sufficient ",
                                                                                  },
                                                                                  Expression {
                                                                                   expression: PropertyAccess {
                                                                                    expression: Variable {
                                                                                     identifier: "pkgs",
                                                                                     position: (553, 31),
                                                                                    },
                                                                                    attribute_path: AttributePath {
                                                                                     attributes: [
                                                                                      Raw {
                                                                                       content: "sssd",
                                                                                       position: (553, 36),
                                                                                      },
                                                                                     ],
                                                                                    },
                                                                                    default: None,
                                                                                   },
                                                                                  },
                                                                                  Raw {
                                                                                   content: "/lib/security/pam_sss.so use_first_pass\n",
                                                                                  },
                                                                                 ],
                                                                                 position: (552, 54),
                                                                                },
                                                                               ],
                                                                              },
                                                                             ],
                                                                             position: (551, 14),
                                                                            },
                                                                            FunctionApplication {
                                                                             function: Variable {
                                                                              identifier: "optionalString",
                                                                              position: (555, 11),
                                                                             },
                                                                             arguments: [
                                                                              PropertyAccess {
                                                                               expression: Variable {
                                                                                identifier: "config",
                                                                                position: (555, 26),
                                                                               },
                                                                               attribute_path: AttributePath {
                                                                                attributes: [
                                                                                 Raw {
                                                                                  content: "krb5",
                                                                                  position: (555, 33),
                                                                                 },
                                                                                 Raw {
                                                                                  content: "enable",
                                                                                  position: (555, 38),
                                                                                 },
                                                                                ],
                                                                               },
                                                                               default: None,
                                                                              },
                                                                              String {
                                                                               parts: [
                                                                                Raw {
                                                                                 content: "auth [default=ignore success=1 service_err=reset] ",
                                                                                },
                                                                                Expression {
                                                                                 expression: Variable {
                                                                                  identifier: "pam_krb5",
                                                                                  position: (556, 65),
                                                                                 },
                                                                                },
                                                                                Raw {
                                                                                 content: "/lib/security/pam_krb5.so use_first_pass\nauth [default=die success=done] ",
                                                                                },
                                                                                Expression {
                                                                                 expression: Variable {
                                                                                  identifier: "pam_ccreds",
                                                                                  position: (557, 47),
                                                                                 },
                                                                                },
                                                                                Raw {
                                                                                 content: "/lib/security/pam_ccreds.so action=validate use_first_pass\nauth sufficient ",
                                                                                },
                                                                                Expression {
                                                                                 expression: Variable {
                                                                                  identifier: "pam_ccreds",
                                                                                  position: (558, 31),
                                                                                 },
                                                                                },
                                                                                Raw {
                                                                                 content: "/lib/security/pam_ccreds.so action=store use_first_pass\n",
                                                                                },
                                                                               ],
                                                                               position: (555, 45),
                                                                              },
                                                                             ],
                                                                            },
                                                                           ],
                                                                           position: (554, 14),
                                                                          },
                                                                          String {
                                                                           parts: [
                                                                            Raw {
                                                                             content: "auth required pam_deny.so\n\n# Password management.\npassword sufficient pam_unix.so nullok sha512\n",
                                                                            },
                                                                           ],
                                                                           position: (560, 11),
                                                                          },
                                                                         ],
                                                                         position: (559, 14),
                                                                        },
                                                                        FunctionApplication {
                                                                         function: Variable {
                                                                          identifier: "optionalString",
                                                                          position: (566, 11),
                                                                         },
                                                                         arguments: [
                                                                          PropertyAccess {
                                                                           expression: Variable {
                                                                            identifier: "config",
                                                                            position: (566, 26),
                                                                           },
                                                                           attribute_path: AttributePath {
                                                                            attributes: [
                                                                             Raw {
                                                                              content: "security",
                                                                              position: (566, 33),
                                                                             },
                                                                             Raw {
                                                                              content: "pam",
                                                                              position: (566, 42),
                                                                             },
                                                                             Raw {
                                                                              content: "enableEcryptfs",
                                                                              position: (566, 46),
                                                                             },
                                                                            ],
                                                                           },
                                                                           default: None,
                                                                          },
                                                                          String {
                                                                           parts: [
                                                                            Raw {
                                                                             content: "password optional ",
                                                                            },
                                                                            Expression {
                                                                             expression: PropertyAccess {
                                                                              expression: Variable {
                                                                               identifier: "pkgs",
                                                                               position: (567, 33),
                                                                              },
                                                                              attribute_path: AttributePath {
                                                                               attributes: [
                                                                                Raw {
                                                                                 content: "ecryptfs",
                                                                                 position: (567, 38),
                                                                                },
                                                                               ],
                                                                              },
                                                                              default: None,
                                                                             },
                                                                            },
                                                                            Raw {
                                                                             content: "/lib/security/pam_ecryptfs.so\n",
                                                                            },
                                                                           ],
                                                                           position: (566, 61),
                                                                          },
                                                                         ],
                                                                        },
                                                                       ],
                                                                       position: (565, 14),
                                                                      },
                                                                      FunctionApplication {
                                                                       function: Variable {
                                                                        identifier: "optionalString",
                                                                        position: (569, 11),
                                                                       },
                                                                       arguments: [
                                                                        PropertyAccess {
                                                                         expression: Variable {
                                                                          identifier: "cfg",
                                                                          position: (569, 26),
                                                                         },
                                                                         attribute_path: AttributePath {
                                                                          attributes: [
                                                                           Raw {
                                                                            content: "pamMount",
                                                                            position: (569, 30),
                                                                           },
                                                                          ],
                                                                         },
                                                                         default: None,
                                                                        },
                                                                        String {
                                                                         parts: [
                                                                          Raw {
                                                                           content: "password optional ",
                                                                          },
                                                                          Expression {
                                                                           expression: PropertyAccess {
                                                                            expression: Variable {
                                                                             identifier: "pkgs",
                                                                             position: (570, 33),
                                                                            },
                                                                            attribute_path: AttributePath {
                                                                             attributes: [
                                                                              Raw {
                                                                               content: "pam_mount",
                                                                               position: (570, 38),
                                                                              },
                                                                             ],
                                                                            },
                                                                            default: None,
                                                                           },
                                                                          },
                                                                          Raw {
                                                                           content: "/lib/security/pam_mount.so\n",
                                                                          },
                                                                         ],
                                                                         position: (569, 39),
                                                                        },
                                                                       ],
                                                                      },
                                                                     ],
                                                                     position: (568, 14),
                                                                    },
                                                                    FunctionApplication {
                                                                     function: Variable {
                                                                      identifier: "optionalString",
                                                                      position: (572, 11),
                                                                     },
                                                                     arguments: [
                                                                      Variable {
                                                                       identifier: "use_ldap",
                                                                       position: (572, 26),
                                                                      },
                                                                      String {
                                                                       parts: [
                                                                        Raw {
                                                                         content: "password sufficient ",
                                                                        },
                                                                        Expression {
                                                                         expression: Variable {
                                                                          identifier: "pam_ldap",
                                                                          position: (573, 35),
                                                                         },
                                                                        },
                                                                        Raw {
                                                                         content: "/lib/security/pam_ldap.so\n",
                                                                        },
                                                                       ],
                                                                       position: (572, 35),
                                                                      },
                                                                     ],
                                                                    },
                                                                   ],
                                                                   position: (571, 14),
                                                                  },
                                                                  FunctionApplication {
                                                                   function: Variable {
                                                                    identifier: "optionalString",
                                                                    position: (575, 11),
                                                                   },
                                                                   arguments: [
                                                                    PropertyAccess {
                                                                     expression: Variable {
                                                                      identifier: "config",
                                                                      position: (575, 26),
                                                                     },
                                                                     attribute_path: AttributePath {
                                                                      attributes: [
                                                                       Raw {
                                                                        content: "services",
                                                                        position: (575, 33),
                                                                       },
                                                                       Raw {
                                                                        content: "sssd",
                                                                        position: (575, 42),
                                                                       },
                                                                       Raw {
                                                                        content: "enable",
                                                                        position: (575, 47),
                                                                       },
                                                                      ],
                                                                     },
                                                                     default: None,
                                                                    },
                                                                    String {
                                                                     parts: [
                                                                      Raw {
                                                                       content: "password sufficient ",
                                                                      },
                                                                      Expression {
                                                                       expression: PropertyAccess {
                                                                        expression: Variable {
                                                                         identifier: "pkgs",
                                                                         position: (576, 35),
                                                                        },
                                                                        attribute_path: AttributePath {
                                                                         attributes: [
                                                                          Raw {
                                                                           content: "sssd",
                                                                           position: (576, 40),
                                                                          },
                                                                         ],
                                                                        },
                                                                        default: None,
                                                                       },
                                                                      },
                                                                      Raw {
                                                                       content: "/lib/security/pam_sss.so use_authtok\n",
                                                                      },
                                                                     ],
                                                                     position: (575, 54),
                                                                    },
                                                                   ],
                                                                  },
                                                                 ],
                                                                 position: (574, 14),
                                                                },
                                                                FunctionApplication {
                                                                 function: Variable {
                                                                  identifier: "optionalString",
                                                                  position: (578, 11),
                                                                 },
                                                                 arguments: [
                                                                  PropertyAccess {
                                                                   expression: Variable {
                                                                    identifier: "config",
                                                                    position: (578, 26),
                                                                   },
                                                                   attribute_path: AttributePath {
                                                                    attributes: [
                                                                     Raw {
                                                                      content: "krb5",
                                                                      position: (578, 33),
                                                                     },
                                                                     Raw {
                                                                      content: "enable",
                                                                      position: (578, 38),
                                                                     },
                                                                    ],
                                                                   },
                                                                   default: None,
                                                                  },
                                                                  String {
                                                                   parts: [
                                                                    Raw {
                                                                     content: "password sufficient ",
                                                                    },
                                                                    Expression {
                                                                     expression: Variable {
                                                                      identifier: "pam_krb5",
                                                                      position: (579, 35),
                                                                     },
                                                                    },
                                                                    Raw {
                                                                     content: "/lib/security/pam_krb5.so use_first_pass\n",
                                                                    },
                                                                   ],
                                                                   position: (578, 45),
                                                                  },
                                                                 ],
                                                                },
                                                               ],
                                                               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: "enableGnomeKeyring",
                                                                    position: (581, 30),
                                                                   },
                                                                  ],
                                                                 },
                                                                 default: None,
                                                                },
                                                                String {
                                                                 parts: [
                                                                  Raw {
                                                                   content: "password optional ",
                                                                  },
                                                                  Expression {
                                                                   expression: PropertyAccess {
                                                                    expression: Variable {
                                                                     identifier: "pkgs",
                                                                     position: (582, 33),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                     attributes: [
                                                                      Raw {
                                                                       content: "gnome",
                                                                       position: (582, 38),
                                                                      },
                                                                      Raw {
                                                                       content: "gnome-keyring",
                                                                       position: (582, 44),
                                                                      },
                                                                     ],
                                                                    },
                                                                    default: None,
                                                                   },
                                                                  },
                                                                  Raw {
                                                                   content: "/lib/security/pam_gnome_keyring.so use_authtok\n",
                                                                  },
                                                                 ],
                                                                 position: (581, 49),
                                                                },
                                                               ],
                                                              },
                                                             ],
                                                             position: (580, 14),
                                                            },
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "\n# Session management.\n",
                                                              },
                                                             ],
                                                             position: (584, 11),
                                                            },
                                                           ],
                                                           position: (583, 14),
                                                          },
                                                          FunctionApplication {
                                                           function: Variable {
                                                            identifier: "optionalString",
                                                            position: (588, 11),
                                                           },
                                                           arguments: [
                                                            PropertyAccess {
                                                             expression: Variable {
                                                              identifier: "cfg",
                                                              position: (588, 26),
                                                             },
                                                             attribute_path: AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "setEnvironment",
                                                                position: (588, 30),
                                                               },
                                                              ],
                                                             },
                                                             default: None,
                                                            },
                                                            String {
                                                             parts: [
                                                              Raw {
                                                               content: "session required pam_env.so conffile=/etc/pam/environment readenv=0\n",
                                                              },
                                                             ],
                                                             position: (588, 45),
                                                            },
                                                           ],
                                                          },
                                                         ],
                                                         position: (587, 14),
                                                        },
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "session required pam_unix.so\n",
                                                          },
                                                         ],
                                                         position: (591, 11),
                                                        },
                                                       ],
                                                       position: (590, 14),
                                                      },
                                                      FunctionApplication {
                                                       function: Variable {
                                                        identifier: "optionalString",
                                                        position: (594, 11),
                                                       },
                                                       arguments: [
                                                        PropertyAccess {
                                                         expression: Variable {
                                                          identifier: "cfg",
                                                          position: (594, 26),
                                                         },
                                                         attribute_path: AttributePath {
                                                          attributes: [
                                                           Raw {
                                                            content: "setLoginUid",
                                                            position: (594, 30),
                                                           },
                                                          ],
                                                         },
                                                         default: None,
                                                        },
                                                        String {
                                                         parts: [
                                                          Raw {
                                                           content: "session ",
                                                          },
                                                          Expression {
                                                           expression: IfThenElse {
                                                            predicate: PropertyAccess {
                                                             expression: Variable {
                                                              identifier: "config",
                                                              position: (595, 26),
                                                             },
                                                             attribute_path: AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "boot",
                                                                position: (595, 33),
                                                               },
                                                               Raw {
                                                                content: "isContainer",
                                                                position: (595, 38),
                                                               },
                                                              ],
                                                             },
                                                             default: None,
                                                            },
                                                            then: String {
                                                             parts: [
                                                              Raw {
                                                               content: "optional",
                                                              },
                                                             ],
                                                             position: (595, 55),
                                                            },
                                                            else_: String {
                                                             parts: [
                                                              Raw {
                                                               content: "required",
                                                              },
                                                             ],
                                                             position: (595, 71),
                                                            },
                                                            position: (595, 23),
                                                           },
                                                          },
                                                          Raw {
                                                           content: " pam_loginuid.so\n",
                                                          },
                                                         ],
                                                         position: (594, 42),
                                                        },
                                                       ],
                                                      },
                                                     ],
                                                     position: (593, 14),
                                                    },
                                                    FunctionApplication {
                                                     function: Variable {
                                                      identifier: "optionalString",
                                                      position: (597, 11),
                                                     },
                                                     arguments: [
                                                      PropertyAccess {
                                                       expression: Variable {
                                                        identifier: "cfg",
                                                        position: (597, 26),
                                                       },
                                                       attribute_path: AttributePath {
                                                        attributes: [
                                                         Raw {
                                                          content: "ttyAudit",
                                                          position: (597, 30),
                                                         },
                                                         Raw {
                                                          content: "enable",
                                                          position: (597, 39),
                                                         },
                                                        ],
                                                       },
                                                       default: None,
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "session required ",
                                                        },
                                                        Expression {
                                                         expression: PropertyAccess {
                                                          expression: Variable {
                                                           identifier: "pkgs",
                                                           position: (598, 32),
                                                          },
                                                          attribute_path: AttributePath {
                                                           attributes: [
                                                            Raw {
                                                             content: "pam",
                                                             position: (598, 37),
                                                            },
                                                           ],
                                                          },
                                                          default: None,
                                                         },
                                                        },
                                                        Raw {
                                                         content: "/lib/security/pam_tty_audit.so\n    open_only=",
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "toString",
                                                           position: (599, 29),
                                                          },
                                                          arguments: [
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "cfg",
                                                             position: (599, 38),
                                                            },
                                                            attribute_path: AttributePath {
                                                             attributes: [
                                                              Raw {
                                                               content: "ttyAudit",
                                                               position: (599, 42),
                                                              },
                                                              Raw {
                                                               content: "openOnly",
                                                               position: (599, 51),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "\n    ",
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "optionalString",
                                                           position: (600, 19),
                                                          },
                                                          arguments: [
                                                           BinaryOperation {
                                                            operator: NotEqualTo,
                                                            operands: [
                                                             PropertyAccess {
                                                              expression: Variable {
                                                               identifier: "cfg",
                                                               position: (600, 35),
                                                              },
                                                              attribute_path: AttributePath {
                                                               attributes: [
                                                                Raw {
                                                                 content: "ttyAudit",
                                                                 position: (600, 39),
                                                                },
                                                                Raw {
                                                                 content: "enablePattern",
                                                                 position: (600, 48),
                                                                },
                                                               ],
                                                              },
                                                              default: None,
                                                             },
                                                             Variable {
                                                              identifier: "null",
                                                              position: (600, 65),
                                                             },
                                                            ],
                                                            position: (600, 62),
                                                           },
                                                           String {
                                                            parts: [
                                                             Raw {
                                                              content: "enable=",
                                                             },
                                                             Expression {
                                                              expression: PropertyAccess {
                                                               expression: Variable {
                                                                identifier: "cfg",
                                                                position: (600, 81),
                                                               },
                                                               attribute_path: AttributePath {
                                                                attributes: [
                                                                 Raw {
                                                                  content: "ttyAudit",
                                                                  position: (600, 85),
                                                                 },
                                                                 Raw {
                                                                  content: "enablePattern",
                                                                  position: (600, 94),
                                                                 },
                                                                ],
                                                               },
                                                               default: None,
                                                              },
                                                             },
                                                            ],
                                                            position: (600, 71),
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "\n    ",
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "optionalString",
                                                           position: (601, 19),
                                                          },
                                                          arguments: [
                                                           BinaryOperation {
                                                            operator: NotEqualTo,
                                                            operands: [
                                                             PropertyAccess {
                                                              expression: Variable {
                                                               identifier: "cfg",
                                                               position: (601, 35),
                                                              },
                                                              attribute_path: AttributePath {
                                                               attributes: [
                                                                Raw {
                                                                 content: "ttyAudit",
                                                                 position: (601, 39),
                                                                },
                                                                Raw {
                                                                 content: "disablePattern",
                                                                 position: (601, 48),
                                                                },
                                                               ],
                                                              },
                                                              default: None,
                                                             },
                                                             Variable {
                                                              identifier: "null",
                                                              position: (601, 66),
                                                             },
                                                            ],
                                                            position: (601, 63),
                                                           },
                                                           String {
                                                            parts: [
                                                             Raw {
                                                              content: "disable=",
                                                             },
                                                             Expression {
                                                              expression: PropertyAccess {
                                                               expression: Variable {
                                                                identifier: "cfg",
                                                                position: (601, 83),
                                                               },
                                                               attribute_path: AttributePath {
                                                                attributes: [
                                                                 Raw {
                                                                  content: "ttyAudit",
                                                                  position: (601, 87),
                                                                 },
                                                                 Raw {
                                                                  content: "disablePattern",
                                                                  position: (601, 96),
                                                                 },
                                                                ],
                                                               },
                                                               default: None,
                                                              },
                                                             },
                                                            ],
                                                            position: (601, 72),
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "\n",
                                                        },
                                                       ],
                                                       position: (597, 46),
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                   position: (596, 14),
                                                  },
                                                  FunctionApplication {
                                                   function: Variable {
                                                    identifier: "optionalString",
                                                    position: (603, 11),
                                                   },
                                                   arguments: [
                                                    PropertyAccess {
                                                     expression: Variable {
                                                      identifier: "cfg",
                                                      position: (603, 26),
                                                     },
                                                     attribute_path: AttributePath {
                                                      attributes: [
                                                       Raw {
                                                        content: "makeHomeDir",
                                                        position: (603, 30),
                                                       },
                                                      ],
                                                     },
                                                     default: None,
                                                    },
                                                    String {
                                                     parts: [
                                                      Raw {
                                                       content: "session required ",
                                                      },
                                                      Expression {
                                                       expression: PropertyAccess {
                                                        expression: Variable {
                                                         identifier: "pkgs",
                                                         position: (604, 32),
                                                        },
                                                        attribute_path: AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "pam",
                                                           position: (604, 37),
                                                          },
                                                         ],
                                                        },
                                                        default: None,
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/pam_mkhomedir.so silent skel=",
                                                      },
                                                      Expression {
                                                       expression: PropertyAccess {
                                                        expression: Variable {
                                                         identifier: "config",
                                                         position: (604, 86),
                                                        },
                                                        attribute_path: AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "security",
                                                           position: (604, 93),
                                                          },
                                                          Raw {
                                                           content: "pam",
                                                           position: (604, 102),
                                                          },
                                                          Raw {
                                                           content: "makeHomeDir",
                                                           position: (604, 106),
                                                          },
                                                          Raw {
                                                           content: "skelDirectory",
                                                           position: (604, 118),
                                                          },
                                                         ],
                                                        },
                                                        default: None,
                                                       },
                                                      },
                                                      Raw {
                                                       content: " umask=0077\n",
                                                      },
                                                     ],
                                                     position: (603, 42),
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                 position: (602, 14),
                                                },
                                                FunctionApplication {
                                                 function: Variable {
                                                  identifier: "optionalString",
                                                  position: (606, 11),
                                                 },
                                                 arguments: [
                                                  PropertyAccess {
                                                   expression: Variable {
                                                    identifier: "cfg",
                                                    position: (606, 26),
                                                   },
                                                   attribute_path: AttributePath {
                                                    attributes: [
                                                     Raw {
                                                      content: "updateWtmp",
                                                      position: (606, 30),
                                                     },
                                                    ],
                                                   },
                                                   default: None,
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "session required ",
                                                    },
                                                    Expression {
                                                     expression: PropertyAccess {
                                                      expression: Variable {
                                                       identifier: "pkgs",
                                                       position: (607, 32),
                                                      },
                                                      attribute_path: AttributePath {
                                                       attributes: [
                                                        Raw {
                                                         content: "pam",
                                                         position: (607, 37),
                                                        },
                                                       ],
                                                      },
                                                      default: None,
                                                     },
                                                    },
                                                    Raw {
                                                     content: "/lib/security/pam_lastlog.so silent\n",
                                                    },
                                                   ],
                                                   position: (606, 41),
                                                  },
                                                 ],
                                                },
                                               ],
                                               position: (605, 14),
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "optionalString",
                                                position: (609, 11),
                                               },
                                               arguments: [
                                                PropertyAccess {
                                                 expression: Variable {
                                                  identifier: "config",
                                                  position: (609, 26),
                                                 },
                                                 attribute_path: AttributePath {
                                                  attributes: [
                                                   Raw {
                                                    content: "security",
                                                    position: (609, 33),
                                                   },
                                                   Raw {
                                                    content: "pam",
                                                    position: (609, 42),
                                                   },
                                                   Raw {
                                                    content: "enableEcryptfs",
                                                    position: (609, 46),
                                                   },
                                                  ],
                                                 },
                                                 default: None,
                                                },
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "session optional ",
                                                  },
                                                  Expression {
                                                   expression: PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "pkgs",
                                                     position: (610, 32),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "ecryptfs",
                                                       position: (610, 37),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                  },
                                                  Raw {
                                                   content: "/lib/security/pam_ecryptfs.so\n",
                                                  },
                                                 ],
                                                 position: (609, 61),
                                                },
                                               ],
                                              },
                                             ],
                                             position: (608, 14),
                                            },
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "optionalString",
                                              position: (612, 11),
                                             },
                                             arguments: [
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "cfg",
                                                position: (612, 26),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "pamMount",
                                                  position: (612, 30),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "session [success=1 default=ignore] ",
                                                },
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "pkgs",
                                                   position: (613, 50),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "pam",
                                                     position: (613, 55),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: "/lib/security/pam_succeed_if.so service = systemd-user quiet\nsession optional ",
                                                },
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "pkgs",
                                                   position: (614, 32),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "pam_mount",
                                                     position: (614, 37),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: "/lib/security/pam_mount.so disable_interactive\n",
                                                },
                                               ],
                                               position: (612, 39),
                                              },
                                             ],
                                            },
                                           ],
                                           position: (611, 14),
                                          },
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "optionalString",
                                            position: (616, 11),
                                           },
                                           arguments: [
                                            Variable {
                                             identifier: "use_ldap",
                                             position: (616, 26),
                                            },
                                            String {
                                             parts: [
                                              Raw {
                                               content: "session optional ",
                                              },
                                              Expression {
                                               expression: Variable {
                                                identifier: "pam_ldap",
                                                position: (617, 32),
                                               },
                                              },
                                              Raw {
                                               content: "/lib/security/pam_ldap.so\n",
                                              },
                                             ],
                                             position: (616, 35),
                                            },
                                           ],
                                          },
                                         ],
                                         position: (615, 14),
                                        },
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "optionalString",
                                          position: (619, 11),
                                         },
                                         arguments: [
                                          PropertyAccess {
                                           expression: Variable {
                                            identifier: "config",
                                            position: (619, 26),
                                           },
                                           attribute_path: AttributePath {
                                            attributes: [
                                             Raw {
                                              content: "services",
                                              position: (619, 33),
                                             },
                                             Raw {
                                              content: "sssd",
                                              position: (619, 42),
                                             },
                                             Raw {
                                              content: "enable",
                                              position: (619, 47),
                                             },
                                            ],
                                           },
                                           default: None,
                                          },
                                          String {
                                           parts: [
                                            Raw {
                                             content: "session optional ",
                                            },
                                            Expression {
                                             expression: PropertyAccess {
                                              expression: Variable {
                                               identifier: "pkgs",
                                               position: (620, 32),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "sssd",
                                                 position: (620, 37),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                            },
                                            Raw {
                                             content: "/lib/security/pam_sss.so\n",
                                            },
                                           ],
                                           position: (619, 54),
                                          },
                                         ],
                                        },
                                       ],
                                       position: (618, 14),
                                      },
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "optionalString",
                                        position: (622, 11),
                                       },
                                       arguments: [
                                        PropertyAccess {
                                         expression: Variable {
                                          identifier: "config",
                                          position: (622, 26),
                                         },
                                         attribute_path: AttributePath {
                                          attributes: [
                                           Raw {
                                            content: "krb5",
                                            position: (622, 33),
                                           },
                                           Raw {
                                            content: "enable",
                                            position: (622, 38),
                                           },
                                          ],
                                         },
                                         default: None,
                                        },
                                        String {
                                         parts: [
                                          Raw {
                                           content: "session optional ",
                                          },
                                          Expression {
                                           expression: Variable {
                                            identifier: "pam_krb5",
                                            position: (623, 32),
                                           },
                                          },
                                          Raw {
                                           content: "/lib/security/pam_krb5.so\n",
                                          },
                                         ],
                                         position: (622, 45),
                                        },
                                       ],
                                      },
                                     ],
                                     position: (621, 14),
                                    },
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "optionalString",
                                      position: (625, 11),
                                     },
                                     arguments: [
                                      PropertyAccess {
                                       expression: Variable {
                                        identifier: "cfg",
                                        position: (625, 26),
                                       },
                                       attribute_path: AttributePath {
                                        attributes: [
                                         Raw {
                                          content: "otpwAuth",
                                          position: (625, 30),
                                         },
                                        ],
                                       },
                                       default: None,
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "session optional ",
                                        },
                                        Expression {
                                         expression: PropertyAccess {
                                          expression: Variable {
                                           identifier: "pkgs",
                                           position: (626, 32),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "otpw",
                                             position: (626, 37),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                        },
                                        Raw {
                                         content: "/lib/security/pam_otpw.so\n",
                                        },
                                       ],
                                       position: (625, 39),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (624, 14),
                                  },
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "optionalString",
                                    position: (628, 11),
                                   },
                                   arguments: [
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "cfg",
                                      position: (628, 26),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "startSession",
                                        position: (628, 30),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "session optional ",
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (629, 32),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "systemd",
                                           position: (629, 37),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/lib/security/pam_systemd.so\n",
                                      },
                                     ],
                                     position: (628, 43),
                                    },
                                   ],
                                  },
                                 ],
                                 position: (627, 14),
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "optionalString",
                                  position: (631, 11),
                                 },
                                 arguments: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (631, 26),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "forwardXAuth",
                                      position: (631, 30),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "session optional pam_xauth.so xauthpath=",
                                    },
                                    Expression {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "pkgs",
                                       position: (632, 55),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "xorg",
                                         position: (632, 60),
                                        },
                                        Raw {
                                         content: "xauth",
                                         position: (632, 65),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                    Raw {
                                     content: "/bin/xauth systemuser=99\n",
                                    },
                                   ],
                                   position: (631, 43),
                                  },
                                 ],
                                },
                               ],
                               position: (630, 14),
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "optionalString",
                                position: (634, 11),
                               },
                               arguments: [
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "cfg",
                                    position: (634, 27),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "limits",
                                      position: (634, 31),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  List {
                                   elements: [],
                                   position: (634, 41),
                                  },
                                 ],
                                 position: (634, 38),
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "session required ",
                                  },
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (635, 32),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "pam",
                                       position: (635, 37),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/lib/security/pam_limits.so conf=",
                                  },
                                  Expression {
                                   expression: FunctionApplication {
                                    function: Variable {
                                     identifier: "makeLimitsConf",
                                     position: (635, 76),
                                    },
                                    arguments: [
                                     PropertyAccess {
                                      expression: Variable {
                                       identifier: "cfg",
                                       position: (635, 91),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "limits",
                                         position: (635, 95),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    ],
                                   },
                                  },
                                  Raw {
                                   content: "\n",
                                  },
                                 ],
                                 position: (634, 45),
                                },
                               ],
                              },
                             ],
                             position: (633, 14),
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "optionalString",
                              position: (637, 11),
                             },
                             arguments: [
                              BinaryOperation {
                               operator: LogicalAnd,
                               operands: [
                                PropertyAccess {
                                 expression: Variable {
                                  identifier: "cfg",
                                  position: (637, 27),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "showMotd",
                                    position: (637, 31),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                BinaryOperation {
                                 operator: NotEqualTo,
                                 operands: [
                                  PropertyAccess {
                                   expression: Variable {
                                    identifier: "config",
                                    position: (637, 43),
                                   },
                                   attribute_path: AttributePath {
                                    attributes: [
                                     Raw {
                                      content: "users",
                                      position: (637, 50),
                                     },
                                     Raw {
                                      content: "motd",
                                      position: (637, 56),
                                     },
                                    ],
                                   },
                                   default: None,
                                  },
                                  Variable {
                                   identifier: "null",
                                   position: (637, 64),
                                  },
                                 ],
                                 position: (637, 61),
                                },
                               ],
                               position: (637, 40),
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "session optional ",
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (638, 32),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "pam",
                                     position: (638, 37),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/lib/security/pam_motd.so motd=",
                                },
                                Expression {
                                 expression: Variable {
                                  identifier: "motd",
                                  position: (638, 74),
                                 },
                                },
                                Raw {
                                 content: "\n",
                                },
                               ],
                               position: (637, 70),
                              },
                             ],
                            },
                           ],
                           position: (636, 14),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "optionalString",
                            position: (640, 11),
                           },
                           arguments: [
                            BinaryOperation {
                             operator: LogicalAnd,
                             operands: [
                              PropertyAccess {
                               expression: Variable {
                                identifier: "cfg",
                                position: (640, 27),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "enableAppArmor",
                                  position: (640, 31),
                                 },
                                ],
                               },
                               default: None,
                              },
                              PropertyAccess {
                               expression: Variable {
                                identifier: "config",
                                position: (640, 49),
                               },
                               attribute_path: AttributePath {
                                attributes: [
                                 Raw {
                                  content: "security",
                                  position: (640, 56),
                                 },
                                 Raw {
                                  content: "apparmor",
                                  position: (640, 65),
                                 },
                                 Raw {
                                  content: "enable",
                                  position: (640, 74),
                                 },
                                ],
                               },
                               default: None,
                              },
                             ],
                             position: (640, 46),
                            },
                            String {
                             parts: [
                              Raw {
                               content: "session optional ",
                              },
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (641, 32),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "apparmor-pam",
                                   position: (641, 37),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: "/lib/security/pam_apparmor.so order=user,group,default debug\n",
                              },
                             ],
                             position: (640, 82),
                            },
                           ],
                          },
                         ],
                         position: (639, 14),
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "optionalString",
                          position: (643, 11),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (643, 27),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "enableKwallet",
                              position: (643, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [
                            Raw {
                             content: "session optional ",
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (644, 32),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "plasma5Packages",
                                 position: (644, 37),
                                },
                                Raw {
                                 content: "kwallet-pam",
                                 position: (644, 53),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/lib/security/pam_kwallet5.so kwalletd=",
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (644, 106),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "plasma5Packages",
                                 position: (644, 111),
                                },
                                Raw {
                                 content: "kwallet",
                                 position: (644, 127),
                                },
                                Raw {
                                 content: "bin",
                                 position: (644, 135),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/bin/kwalletd5\n",
                            },
                           ],
                           position: (643, 46),
                          },
                         ],
                        },
                       ],
                       position: (642, 14),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (646, 11),
                       },
                       arguments: [
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (646, 27),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "enableGnomeKeyring",
                            position: (646, 31),
                           },
                          ],
                         },
                         default: None,
                        },
                        String {
                         parts: [
                          Raw {
                           content: "session optional ",
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (647, 32),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "gnome",
                               position: (647, 37),
                              },
                              Raw {
                               content: "gnome-keyring",
                               position: (647, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/lib/security/pam_gnome_keyring.so auto_start\n",
                          },
                         ],
                         position: (646, 51),
                        },
                       ],
                      },
                     ],
                     position: (645, 14),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (649, 11),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (649, 26),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "gnupg",
                          position: (649, 30),
                         },
                         Raw {
                          content: "enable",
                          position: (649, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                      String {
                       parts: [
                        Raw {
                         content: "session optional ",
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (650, 32),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "pam_gnupg",
                             position: (650, 37),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/lib/security/pam_gnupg.so ",
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "optionalString",
                           position: (650, 76),
                          },
                          arguments: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (650, 91),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "gnupg",
                               position: (650, 95),
                              },
                              Raw {
                               content: "noAutostart",
                               position: (650, 101),
                              },
                             ],
                            },
                            default: None,
                           },
                           String {
                            parts: [
                             Raw {
                              content: " no-autostart",
                             },
                            ],
                            position: (650, 113),
                           },
                          ],
                         },
                        },
                        Raw {
                         content: "\n",
                        },
                       ],
                       position: (649, 43),
                      },
                     ],
                    },
                   ],
                   position: (648, 14),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optionalString",
                    position: (652, 11),
                   },
                   arguments: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (652, 27),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "virtualisation",
                        position: (652, 34),
                       },
                       Raw {
                        content: "lxc",
                        position: (652, 49),
                       },
                       Raw {
                        content: "lxcfs",
                        position: (652, 53),
                       },
                       Raw {
                        content: "enable",
                        position: (652, 59),
                       },
                      ],
                     },
                     default: None,
                    },
                    String {
                     parts: [
                      Raw {
                       content: "session optional ",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (653, 32),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "lxc",
                           position: (653, 37),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/lib/security/pam_cgfs.so -c all\n",
                      },
                     ],
                     position: (652, 67),
                    },
                   ],
                  },
                 ],
                 position: (651, 14),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (433, 14),
           },
          ),
         ],
         recursive: false,
         position: (11, 87),
        },
        position: (11, 57),
       },
       position: (11, 36),
      },
      position: (11, 13),
     },
    ),
    Inherit(
     Some(
      Variable {
       identifier: "pkgs",
       position: (661, 12),
      },
     ),
     [
      Raw {
       content: "pam_krb5",
       position: (661, 18),
      },
      Raw {
       content: "pam_ccreds",
       position: (661, 27),
      },
     ],
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "use_ldap",
        position: (663, 3),
       },
      ],
     },
     BinaryOperation {
      operator: LogicalAnd,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (663, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "users",
           position: (663, 22),
          },
          Raw {
           content: "ldap",
           position: (663, 28),
          },
          Raw {
           content: "enable",
           position: (663, 33),
          },
         ],
        },
        default: None,
       },
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (663, 43),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "users",
           position: (663, 50),
          },
          Raw {
           content: "ldap",
           position: (663, 56),
          },
          Raw {
           content: "loginPam",
           position: (663, 61),
          },
         ],
        },
        default: None,
       },
      ],
      position: (663, 40),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "pam_ldap",
        position: (664, 3),
       },
      ],
     },
     IfThenElse {
      predicate: PropertyAccess {
       expression: Variable {
        identifier: "config",
        position: (664, 17),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "users",
          position: (664, 24),
         },
         Raw {
          content: "ldap",
          position: (664, 30),
         },
         Raw {
          content: "daemon",
          position: (664, 35),
         },
         Raw {
          content: "enable",
          position: (664, 42),
         },
        ],
       },
       default: None,
      },
      then: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (664, 54),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "nss_pam_ldapd",
          position: (664, 59),
         },
        ],
       },
       default: None,
      },
      else_: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (664, 78),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "pam_ldap",
          position: (664, 83),
         },
        ],
       },
       default: None,
      },
      position: (664, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeLimitsConf",
        position: (667, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "limits",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "pkgs",
         position: (668, 5),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "writeText",
           position: (668, 10),
          },
         ],
        },
        default: None,
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "limits.conf",
          },
         ],
         position: (668, 20),
        },
        FunctionApplication {
         function: Variable {
          identifier: "concatMapStrings",
          position: (669, 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: (670, 13),
              },
             },
             Raw {
              content: " ",
             },
             Expression {
              expression: Variable {
               identifier: "type",
               position: (670, 23),
              },
             },
             Raw {
              content: " ",
             },
             Expression {
              expression: Variable {
               identifier: "item",
               position: (670, 31),
              },
             },
             Raw {
              content: " ",
             },
             Expression {
              expression: FunctionApplication {
               function: Variable {
                identifier: "toString",
                position: (670, 39),
               },
               arguments: [
                Variable {
                 identifier: "value",
                 position: (670, 48),
                },
               ],
              },
             },
             Raw {
              content: "\n",
             },
            ],
            position: (670, 10),
           },
           position: (669, 27),
          },
          Variable {
           identifier: "limits",
           position: (671, 10),
          },
         ],
        },
       ],
      },
      position: (667, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "limitsType",
        position: (673, 3),
       },
      ],
     },
     With {
      expression: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (673, 21),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "types",
          position: (673, 25),
         },
        ],
       },
       default: None,
      },
      target: FunctionApplication {
       function: Variable {
        identifier: "listOf",
        position: (673, 32),
       },
       arguments: [
        FunctionApplication {
         function: Variable {
          identifier: "submodule",
          position: (673, 40),
         },
         arguments: [
          Function {
           argument: None,
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: true,
           },
           definition: Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "options",
                 position: (674, 5),
                },
               ],
              },
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "domain",
                    position: (675, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (675, 16),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (676, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Username, groupname, or wildcard this limit applies to",
                        },
                       ],
                       position: (676, 23),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "example",
                         position: (677, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "@wheel",
                        },
                       ],
                       position: (677, 19),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (678, 9),
                        },
                       ],
                      },
                      Variable {
                       identifier: "str",
                       position: (678, 16),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (675, 25),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (681, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (681, 14),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (682, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Type of this limit",
                        },
                       ],
                       position: (682, 23),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (683, 9),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "enum",
                        position: (683, 16),
                       },
                       arguments: [
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "-",
                            },
                           ],
                           position: (683, 23),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "hard",
                            },
                           ],
                           position: (683, 27),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "soft",
                            },
                           ],
                           position: (683, 34),
                          },
                         ],
                         position: (683, 21),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "default",
                         position: (684, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "-",
                        },
                       ],
                       position: (684, 19),
                      },
                     ),
                    ],
                    recursive: false,
                    position: (681, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "item",
                    position: (687, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (687, 14),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (688, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Item this limit applies to",
                        },
                       ],
                       position: (688, 23),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (689, 9),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "enum",
                        position: (689, 16),
                       },
                       arguments: [
                        List {
                         elements: [
                          String {
                           parts: [
                            Raw {
                             content: "core",
                            },
                           ],
                           position: (690, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "data",
                            },
                           ],
                           position: (691, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "fsize",
                            },
                           ],
                           position: (692, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "memlock",
                            },
                           ],
                           position: (693, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "nofile",
                            },
                           ],
                           position: (694, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "rss",
                            },
                           ],
                           position: (695, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "stack",
                            },
                           ],
                           position: (696, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "cpu",
                            },
                           ],
                           position: (697, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "nproc",
                            },
                           ],
                           position: (698, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "as",
                            },
                           ],
                           position: (699, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "maxlogins",
                            },
                           ],
                           position: (700, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "maxsyslogins",
                            },
                           ],
                           position: (701, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "priority",
                            },
                           ],
                           position: (702, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "locks",
                            },
                           ],
                           position: (703, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "sigpending",
                            },
                           ],
                           position: (704, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "msgqueue",
                            },
                           ],
                           position: (705, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "nice",
                            },
                           ],
                           position: (706, 11),
                          },
                          String {
                           parts: [
                            Raw {
                             content: "rtprio",
                            },
                           ],
                           position: (707, 11),
                          },
                         ],
                         position: (689, 21),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (687, 23),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "value",
                    position: (711, 7),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "mkOption",
                   position: (711, 15),
                  },
                  arguments: [
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "description",
                         position: (712, 9),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "Value of this limit",
                        },
                       ],
                       position: (712, 23),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "type",
                         position: (713, 9),
                        },
                       ],
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "oneOf",
                        position: (713, 16),
                       },
                       arguments: [
                        List {
                         elements: [
                          Variable {
                           identifier: "str",
                           position: (713, 24),
                          },
                          Variable {
                           identifier: "int",
                           position: (713, 28),
                          },
                         ],
                         position: (713, 22),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (711, 24),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (674, 15),
              },
             ),
            ],
            recursive: false,
            position: (673, 60),
           },
           position: (673, 51),
          },
         ],
        },
       ],
      },
      position: (673, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "motd",
        position: (718, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (718, 10),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (718, 15),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "motd",
         },
        ],
        position: (718, 25),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (718, 32),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "users",
           position: (718, 39),
          },
          Raw {
           content: "motd",
           position: (718, 45),
          },
         ],
        },
        default: None,
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makePAMService",
        position: (720, 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: (721, 7),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "pam.d/",
            },
            Expression {
             expression: Variable {
              identifier: "name",
              position: (721, 23),
             },
            },
           ],
           position: (721, 14),
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "value",
             position: (722, 7),
            },
            Raw {
             content: "source",
             position: (722, 13),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "pkgs",
             position: (722, 22),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "writeText",
               position: (722, 27),
              },
             ],
            },
            default: None,
           },
           arguments: [
            String {
             parts: [
              Expression {
               expression: Variable {
                identifier: "name",
                position: (722, 40),
               },
              },
              Raw {
               content: ".pam",
              },
             ],
             position: (722, 37),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "service",
              position: (722, 51),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "text",
                position: (722, 59),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (721, 5),
       },
       position: (720, 26),
      },
      position: (720, 20),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (729, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRenamedOptionModule",
          position: (730, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "security",
              },
             ],
             position: (730, 30),
            },
            String {
             parts: [
              Raw {
               content: "pam",
              },
             ],
             position: (730, 41),
            },
            String {
             parts: [
              Raw {
               content: "enableU2F",
              },
             ],
             position: (730, 47),
            },
           ],
           position: (730, 28),
          },
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "security",
              },
             ],
             position: (730, 63),
            },
            String {
             parts: [
              Raw {
               content: "pam",
              },
             ],
             position: (730, 74),
            },
            String {
             parts: [
              Raw {
               content: "u2f",
              },
             ],
             position: (730, 80),
            },
            String {
             parts: [
              Raw {
               content: "enable",
              },
             ],
             position: (730, 86),
            },
           ],
           position: (730, 61),
          },
         ],
        },
       ],
       position: (729, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (735, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (737, 5),
           },
           Raw {
            content: "pam",
            position: (737, 14),
           },
           Raw {
            content: "loginLimits",
            position: (737, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (737, 32),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (738, 7),
                },
               ],
              },
              List {
               elements: [],
               position: (738, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (739, 7),
                },
               ],
              },
              Variable {
               identifier: "limitsType",
               position: (739, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (740, 7),
                },
               ],
              },
              List {
               elements: [
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "domain",
                      position: (741, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "ftp",
                     },
                    ],
                    position: (741, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (742, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "hard",
                     },
                    ],
                    position: (742, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "item",
                      position: (743, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "nproc",
                     },
                    ],
                    position: (743, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "value",
                      position: (744, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "0",
                     },
                    ],
                    position: (744, 22),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (741, 11),
                },
                Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "domain",
                      position: (746, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "@student",
                     },
                    ],
                    position: (746, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "type",
                      position: (747, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "-",
                     },
                    ],
                    position: (747, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "item",
                      position: (748, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "maxlogins",
                     },
                    ],
                    position: (748, 22),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "value",
                      position: (749, 13),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "4",
                     },
                    ],
                    position: (749, 22),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (746, 11),
                },
               ],
               position: (741, 9),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (753, 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: (754, 8),
              },
             ),
            ],
            recursive: false,
            position: (737, 41),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (768, 5),
           },
           Raw {
            content: "pam",
            position: (768, 14),
           },
           Raw {
            content: "services",
            position: (768, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (768, 29),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (769, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (769, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (770, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (770, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (770, 26),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (770, 35),
                  },
                  arguments: [
                   Variable {
                    identifier: "pamOpts",
                    position: (770, 45),
                   },
                  ],
                 },
                ],
               },
               position: (770, 14),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (771, 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: (772, 9),
              },
             ),
            ],
            recursive: false,
            position: (768, 38),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (781, 5),
           },
           Raw {
            content: "pam",
            position: (781, 14),
           },
           Raw {
            content: "makeHomeDir",
            position: (781, 18),
           },
           Raw {
            content: "skelDirectory",
            position: (781, 30),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (781, 46),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (782, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (782, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "str",
                  position: (782, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (783, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/var/empty",
                },
               ],
               position: (783, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (784, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/etc/skel",
                },
               ],
               position: (784, 18),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (785, 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: (785, 21),
              },
             ),
            ],
            recursive: false,
            position: (781, 55),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (791, 5),
           },
           Raw {
            content: "pam",
            position: (791, 14),
           },
           Raw {
            content: "enableSSHAgentAuth",
            position: (791, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (791, 39),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (792, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (792, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "bool",
                  position: (792, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (793, 7),
                },
               ],
              },
              Variable {
               identifier: "false",
               position: (793, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (794, 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: (795, 9),
              },
             ),
            ],
            recursive: false,
            position: (791, 48),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (803, 5),
           },
           Raw {
            content: "pam",
            position: (803, 14),
           },
           Raw {
            content: "enableOTPW",
            position: (803, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (803, 31),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "the OTPW (one-time password) PAM module",
             },
            ],
            position: (803, 46),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (805, 5),
           },
           Raw {
            content: "pam",
            position: (805, 14),
           },
           Raw {
            content: "p11",
            position: (805, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (806, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (806, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (807, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (807, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (808, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (808, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (808, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (809, 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: (809, 23),
                 },
                ),
               ],
               recursive: false,
               position: (806, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (819, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (819, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (820, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                   },
                  ],
                  position: (820, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (821, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (821, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (821, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                       },
                      ],
                      position: (821, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                       },
                      ],
                      position: (821, 40),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                       },
                      ],
                      position: (821, 52),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                       },
                      ],
                      position: (821, 65),
                     },
                    ],
                    position: (821, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (822, 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: (822, 23),
                 },
                ),
               ],
               recursive: false,
               position: (819, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (805, 24),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (838, 5),
           },
           Raw {
            content: "pam",
            position: (838, 14),
           },
           Raw {
            content: "u2f",
            position: (838, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (839, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (839, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (840, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (840, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (841, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (841, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (841, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (842, 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: (842, 23),
                 },
                ),
               ],
               recursive: false,
               position: (839, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "authFile",
               position: (860, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (860, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (861, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (861, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (862, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (862, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (862, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (862, 35),
                    },
                   ],
                  },
                  position: (862, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (863, 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: (863, 23),
                 },
                ),
               ],
               recursive: false,
               position: (860, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "appId",
               position: (882, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (882, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (883, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (883, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (884, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (884, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (884, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (884, 35),
                    },
                   ],
                  },
                  position: (884, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (885, 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: (885, 23),
                 },
                ),
               ],
               recursive: false,
               position: (882, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (898, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (898, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (899, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                   },
                  ],
                  position: (899, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (900, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (900, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (900, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                       },
                      ],
                      position: (900, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                       },
                      ],
                      position: (900, 40),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                       },
                      ],
                      position: (900, 52),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                       },
                      ],
                      position: (900, 65),
                     },
                    ],
                    position: (900, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (901, 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: (901, 23),
                 },
                ),
               ],
               recursive: false,
               position: (898, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "debug",
               position: (915, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (915, 15),
             },
             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: "Debug output to stderr.\n",
                   },
                  ],
                  position: (918, 23),
                 },
                ),
               ],
               recursive: false,
               position: (915, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "interactive",
               position: (923, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (923, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (924, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (924, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (925, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (925, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (925, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (926, 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: (926, 23),
                 },
                ),
               ],
               recursive: false,
               position: (923, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "cue",
               position: (932, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (932, 13),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (933, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (933, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (934, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (934, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (934, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (935, 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: (935, 23),
                 },
                ),
               ],
               recursive: false,
               position: (932, 22),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (838, 24),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (946, 5),
           },
           Raw {
            content: "pam",
            position: (946, 14),
           },
           Raw {
            content: "ussh",
            position: (946, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (947, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (947, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (948, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (948, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (949, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (949, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (949, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (950, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Enables Uber's USSH PAM (<literal>pam-ussh</literal>) module.\n\nThis is similar to <literal>pam-ssh-agent</literal>, except that\nthe presence of a CA-signed SSH key with a valid principal is checked\ninstead.\n\nNote that this module must both be enabled using this option and on a\nper-PAM-service level as well (using <literal>usshAuth</literal>).\n\nMore information can be found <link\nxlink:href=\"https://github.com/uber/pam-ussh\">here</link>.\n",
                   },
                  ],
                  position: (950, 23),
                 },
                ),
               ],
               recursive: false,
               position: (947, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "caFile",
               position: (965, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (965, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (966, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (966, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (967, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (967, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (967, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (967, 35),
                    },
                   ],
                  },
                  position: (967, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (968, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "By default <literal>pam-ussh</literal> reads the trusted user CA keys\nfrom <filename>/etc/ssh/trusted_user_ca</filename>.\n\nThis should be set the same as your <literal>TrustedUserCAKeys</literal>\noption for sshd.\n",
                   },
                  ],
                  position: (968, 23),
                 },
                ),
               ],
               recursive: false,
               position: (965, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "authorizedPrincipals",
               position: (977, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (977, 30),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (978, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (978, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (979, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (979, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (979, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "commas",
                     position: (979, 35),
                    },
                   ],
                  },
                  position: (979, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (980, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Comma-separated list of authorized principals to permit; if the user\npresents a certificate with one of these principals, then they will be\nauthorized.\n\nNote that <literal>pam-ussh</literal> also requires that the certificate\ncontain a principal matching the user's username. The principals from\nthis list are in addition to those principals.\n\nMutually exclusive with <literal>authorizedPrincipalsFile</literal>.\n",
                   },
                  ],
                  position: (980, 23),
                 },
                ),
               ],
               recursive: false,
               position: (977, 39),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "authorizedPrincipalsFile",
               position: (993, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (993, 34),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (994, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (994, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (995, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (995, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (995, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "path",
                     position: (995, 35),
                    },
                   ],
                  },
                  position: (995, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (996, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Path to a list of principals; if the user presents a certificate with\none of these principals, then they will be authorized.\n\nNote that <literal>pam-ussh</literal> also requires that the certificate\ncontain a principal matching the user's username. The principals from\nthis file are in addition to those principals.\n\nMutually exclusive with <literal>authorizedPrincipals</literal>.\n",
                   },
                  ],
                  position: (996, 23),
                 },
                ),
               ],
               recursive: false,
               position: (993, 43),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "group",
               position: (1008, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1008, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1009, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (1009, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1010, 9),
                   },
                  ],
                 },
                 With {
                  expression: Variable {
                   identifier: "types",
                   position: (1010, 21),
                  },
                  target: FunctionApplication {
                   function: Variable {
                    identifier: "nullOr",
                    position: (1010, 28),
                   },
                   arguments: [
                    Variable {
                     identifier: "str",
                     position: (1010, 35),
                    },
                   ],
                  },
                  position: (1010, 16),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1011, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "If set, then the authenticating user must be a member of this group\nto use this module.\n",
                   },
                  ],
                  position: (1011, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1008, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (1017, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1017, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1018, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                   },
                  ],
                  position: (1018, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1019, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (1019, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (1019, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                       },
                      ],
                      position: (1019, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                       },
                      ],
                      position: (1019, 40),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                       },
                      ],
                      position: (1019, 52),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                       },
                      ],
                      position: (1019, 65),
                     },
                    ],
                    position: (1019, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1020, 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 SSH certificate 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: (1020, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1017, 26),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (946, 25),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1036, 5),
           },
           Raw {
            content: "pam",
            position: (1036, 14),
           },
           Raw {
            content: "yubico",
            position: (1036, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (1037, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1037, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1038, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (1038, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1039, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (1039, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (1039, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1040, 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: (1040, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1037, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "control",
               position: (1053, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1053, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1054, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "sufficient",
                   },
                  ],
                  position: (1054, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1055, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (1055, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (1055, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "required",
                       },
                      ],
                      position: (1055, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "requisite",
                       },
                      ],
                      position: (1055, 40),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "sufficient",
                       },
                      ],
                      position: (1055, 52),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "optional",
                       },
                      ],
                      position: (1055, 65),
                     },
                    ],
                    position: (1055, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1056, 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: (1056, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1053, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "id",
               position: (1069, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1069, 12),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (1070, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "42",
                   },
                  ],
                  position: (1070, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1071, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (1071, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (1071, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1072, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "client id",
                   },
                  ],
                  position: (1072, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1069, 21),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "debug",
               position: (1075, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1075, 15),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1076, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (1076, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1077, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (1077, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (1077, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1078, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Debug output to stderr.\n",
                   },
                  ],
                  position: (1078, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1075, 24),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mode",
               position: (1082, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1082, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1083, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "client",
                   },
                  ],
                  position: (1083, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1084, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (1084, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "enum",
                      position: (1084, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "client",
                       },
                      ],
                      position: (1084, 29),
                     },
                     String {
                      parts: [
                       Raw {
                        content: "challenge-response",
                       },
                      ],
                      position: (1084, 38),
                     },
                    ],
                    position: (1084, 27),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1085, 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: (1085, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1082, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "challengeResponsePath",
               position: (1099, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (1099, 31),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (1100, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (1100, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (1101, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (1101, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (1101, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (1101, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "path",
                       position: (1101, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (1102, 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: (1102, 23),
                 },
                ),
               ],
               recursive: false,
               position: (1099, 40),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (1036, 27),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1111, 5),
           },
           Raw {
            content: "pam",
            position: (1111, 14),
           },
           Raw {
            content: "enableEcryptfs",
            position: (1111, 18),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (1111, 35),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "eCryptfs PAM module (mounting ecryptfs home directory on login)",
             },
            ],
            position: (1111, 50),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "users",
            position: (1113, 5),
           },
           Raw {
            content: "motd",
            position: (1113, 11),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (1113, 18),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (1114, 7),
                },
               ],
              },
              Variable {
               identifier: "null",
               position: (1114, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "example",
                 position: (1115, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Today is Sweetmorn, the 4th day of The Aftermath in the YOLD 3178.",
                },
               ],
               position: (1115, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (1116, 7),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "types",
                 position: (1116, 14),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "nullOr",
                   position: (1116, 20),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "types",
                  position: (1116, 27),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "lines",
                    position: (1116, 33),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (1117, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Message of the day shown to users when they log in.",
                },
               ],
               position: (1117, 21),
              },
             ),
            ],
            recursive: false,
            position: (1113, 27),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (735, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (1125, 3),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (1127, 5),
           },
           Raw {
            content: "systemPackages",
            position: (1127, 17),
           },
          ],
         },
         BinaryOperation {
          operator: Concatenation,
          operands: [
           List {
            elements: [
             PropertyAccess {
              expression: Variable {
               identifier: "pkgs",
               position: (1129, 9),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "pam",
                 position: (1129, 14),
                },
               ],
              },
              default: None,
             },
            ],
            position: (1129, 7),
           },
           BinaryOperation {
            operator: Concatenation,
            operands: [
             FunctionApplication {
              function: Variable {
               identifier: "optional",
               position: (1130, 10),
              },
              arguments: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (1130, 19),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "users",
                   position: (1130, 26),
                  },
                  Raw {
                   content: "ldap",
                   position: (1130, 32),
                  },
                  Raw {
                   content: "enable",
                   position: (1130, 37),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "pam_ldap",
                position: (1130, 44),
               },
              ],
             },
             BinaryOperation {
              operator: Concatenation,
              operands: [
               FunctionApplication {
                function: Variable {
                 identifier: "optional",
                 position: (1131, 10),
                },
                arguments: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "config",
                   position: (1131, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "services",
                     position: (1131, 26),
                    },
                    Raw {
                     content: "sssd",
                     position: (1131, 35),
                    },
                    Raw {
                     content: "enable",
                     position: (1131, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1131, 47),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "sssd",
                     position: (1131, 52),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
               },
               BinaryOperation {
                operator: Concatenation,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "optionals",
                   position: (1132, 10),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (1132, 20),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "krb5",
                       position: (1132, 27),
                      },
                      Raw {
                       content: "enable",
                       position: (1132, 32),
                      },
                     ],
                    },
                    default: None,
                   },
                   List {
                    elements: [
                     Variable {
                      identifier: "pam_krb5",
                      position: (1132, 40),
                     },
                     Variable {
                      identifier: "pam_ccreds",
                      position: (1132, 49),
                     },
                    ],
                    position: (1132, 39),
                   },
                  ],
                 },
                 BinaryOperation {
                  operator: Concatenation,
                  operands: [
                   FunctionApplication {
                    function: Variable {
                     identifier: "optionals",
                     position: (1133, 10),
                    },
                    arguments: [
                     PropertyAccess {
                      expression: Variable {
                       identifier: "config",
                       position: (1133, 20),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "security",
                         position: (1133, 27),
                        },
                        Raw {
                         content: "pam",
                         position: (1133, 36),
                        },
                        Raw {
                         content: "enableOTPW",
                         position: (1133, 40),
                        },
                       ],
                      },
                      default: None,
                     },
                     List {
                      elements: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (1133, 53),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "otpw",
                           position: (1133, 58),
                          },
                         ],
                        },
                        default: None,
                       },
                      ],
                      position: (1133, 51),
                     },
                    ],
                   },
                   BinaryOperation {
                    operator: Concatenation,
                    operands: [
                     FunctionApplication {
                      function: Variable {
                       identifier: "optionals",
                       position: (1134, 10),
                      },
                      arguments: [
                       PropertyAccess {
                        expression: Variable {
                         identifier: "config",
                         position: (1134, 20),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "security",
                           position: (1134, 27),
                          },
                          Raw {
                           content: "pam",
                           position: (1134, 36),
                          },
                          Raw {
                           content: "oath",
                           position: (1134, 40),
                          },
                          Raw {
                           content: "enable",
                           position: (1134, 45),
                          },
                         ],
                        },
                        default: None,
                       },
                       List {
                        elements: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (1134, 54),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "oathToolkit",
                             position: (1134, 59),
                            },
                           ],
                          },
                          default: None,
                         },
                        ],
                        position: (1134, 52),
                       },
                      ],
                     },
                     BinaryOperation {
                      operator: Concatenation,
                      operands: [
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionals",
                         position: (1135, 10),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "config",
                           position: (1135, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "security",
                             position: (1135, 27),
                            },
                            Raw {
                             content: "pam",
                             position: (1135, 36),
                            },
                            Raw {
                             content: "p11",
                             position: (1135, 40),
                            },
                            Raw {
                             content: "enable",
                             position: (1135, 44),
                            },
                           ],
                          },
                          default: None,
                         },
                         List {
                          elements: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1135, 53),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pam_p11",
                               position: (1135, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                          position: (1135, 51),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: Variable {
                         identifier: "optionals",
                         position: (1136, 10),
                        },
                        arguments: [
                         PropertyAccess {
                          expression: Variable {
                           identifier: "config",
                           position: (1136, 20),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "security",
                             position: (1136, 27),
                            },
                            Raw {
                             content: "pam",
                             position: (1136, 36),
                            },
                            Raw {
                             content: "u2f",
                             position: (1136, 40),
                            },
                            Raw {
                             content: "enable",
                             position: (1136, 44),
                            },
                           ],
                          },
                          default: None,
                         },
                         List {
                          elements: [
                           PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1136, 53),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pam_u2f",
                               position: (1136, 58),
                              },
                             ],
                            },
                            default: None,
                           },
                          ],
                          position: (1136, 51),
                         },
                        ],
                       },
                      ],
                      position: (1136, 7),
                     },
                    ],
                    position: (1135, 7),
                   },
                  ],
                  position: (1134, 7),
                 },
                ],
                position: (1133, 7),
               },
              ],
              position: (1132, 7),
             },
            ],
            position: (1131, 7),
           },
          ],
          position: (1130, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "boot",
            position: (1138, 5),
           },
           Raw {
            content: "supportedFilesystems",
            position: (1138, 10),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "optionals",
           position: (1138, 33),
          },
          arguments: [
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (1138, 43),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "security",
               position: (1138, 50),
              },
              Raw {
               content: "pam",
               position: (1138, 59),
              },
              Raw {
               content: "enableEcryptfs",
               position: (1138, 63),
              },
             ],
            },
            default: None,
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "ecryptfs",
               },
              ],
              position: (1138, 80),
             },
            ],
            position: (1138, 78),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1140, 5),
           },
           Raw {
            content: "wrappers",
            position: (1140, 14),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "unix_chkpwd",
               position: (1141, 7),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "setuid",
                  position: (1142, 9),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (1142, 18),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "owner",
                  position: (1143, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "root",
                 },
                ],
                position: (1143, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "group",
                  position: (1144, 9),
                 },
                ],
               },
               String {
                parts: [
                 Raw {
                  content: "root",
                 },
                ],
                position: (1144, 17),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "source",
                  position: (1145, 9),
                 },
                ],
               },
               String {
                parts: [
                 Expression {
                  expression: PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (1145, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "pam",
                      position: (1145, 26),
                     },
                    ],
                   },
                   default: None,
                  },
                 },
                 Raw {
                  content: "/bin/unix_chkpwd",
                 },
                ],
                position: (1145, 18),
               },
              ),
             ],
             recursive: false,
             position: (1141, 21),
            },
           ),
          ],
          recursive: false,
          position: (1140, 25),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "environment",
            position: (1149, 5),
           },
           Raw {
            content: "etc",
            position: (1149, 17),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mapAttrs'",
           position: (1149, 23),
          },
          arguments: [
           Variable {
            identifier: "makePAMService",
            position: (1149, 33),
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (1149, 48),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "security",
               position: (1149, 55),
              },
              Raw {
               content: "pam",
               position: (1149, 64),
              },
              Raw {
               content: "services",
               position: (1149, 68),
              },
             ],
            },
            default: None,
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1151, 5),
           },
           Raw {
            content: "pam",
            position: (1151, 14),
           },
           Raw {
            content: "services",
            position: (1151, 18),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "other",
               position: (1152, 9),
              },
              Raw {
               content: "text",
               position: (1152, 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: (1153, 11),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "i3lock",
               position: (1165, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1165, 18),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "i3lock-color",
               position: (1166, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1166, 24),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "vlock",
               position: (1167, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1167, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "xlock",
               position: (1168, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1168, 17),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "xscreensaver",
               position: (1169, 9),
              },
             ],
            },
            Map {
             bindings: [],
             recursive: false,
             position: (1169, 24),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "runuser",
               position: (1171, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "rootOK",
                  position: (1171, 21),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (1171, 30),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unixAuth",
                  position: (1171, 36),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (1171, 47),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "setEnvironment",
                  position: (1171, 54),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (1171, 71),
               },
              ),
             ],
             recursive: false,
             position: (1171, 19),
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "runuser-l",
               position: (1176, 9),
              },
             ],
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "rootOK",
                  position: (1176, 23),
                 },
                ],
               },
               Variable {
                identifier: "true",
                position: (1176, 32),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "unixAuth",
                  position: (1176, 38),
                 },
                ],
               },
               Variable {
                identifier: "false",
                position: (1176, 49),
               },
              ),
             ],
             recursive: false,
             position: (1176, 21),
            },
           ),
          ],
          recursive: false,
          position: (1152, 7),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "security",
            position: (1179, 5),
           },
           Raw {
            content: "apparmor",
            position: (1179, 14),
           },
           Raw {
            content: "includes",
            position: (1179, 23),
           },
           Expression {
            expression: __StringParts(
             [
              Raw {
               content: "abstractions/pam",
              },
             ],
            ),
           },
          ],
         },
         LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "isEnabled",
               position: (1180, 7),
              },
             ],
            },
            Function {
             argument: Some(
              "test",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: FunctionApplication {
              function: Variable {
               identifier: "fold",
               position: (1180, 25),
              },
              arguments: [
               Variable {
                identifier: "or",
                position: (1180, 30),
               },
               Variable {
                identifier: "false",
                position: (1180, 33),
               },
               FunctionApplication {
                function: Variable {
                 identifier: "map",
                 position: (1180, 40),
                },
                arguments: [
                 Variable {
                  identifier: "test",
                  position: (1180, 44),
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "attrValues",
                   position: (1180, 50),
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "config",
                     position: (1180, 61),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "security",
                       position: (1180, 68),
                      },
                      Raw {
                       content: "pam",
                       position: (1180, 77),
                      },
                      Raw {
                       content: "services",
                       position: (1180, 81),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ],
               },
              ],
             },
             position: (1180, 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: [
                                                    BinaryOperation {
                                                     operator: Addition,
                                                     operands: [
                                                      FunctionApplication {
                                                       function: PropertyAccess {
                                                        expression: Variable {
                                                         identifier: "lib",
                                                         position: (1182, 7),
                                                        },
                                                        attribute_path: AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "concatMapStrings",
                                                           position: (1182, 11),
                                                          },
                                                         ],
                                                        },
                                                        default: None,
                                                       },
                                                       arguments: [
                                                        Function {
                                                         argument: Some(
                                                          "name",
                                                         ),
                                                         arguments: FunctionArguments {
                                                          arguments: [],
                                                          ellipsis: false,
                                                         },
                                                         definition: String {
                                                          parts: [
                                                           Raw {
                                                            content: "r ",
                                                           },
                                                           Expression {
                                                            expression: PropertyAccess {
                                                             expression: Variable {
                                                              identifier: "config",
                                                              position: (1183, 21),
                                                             },
                                                             attribute_path: AttributePath {
                                                              attributes: [
                                                               Raw {
                                                                content: "environment",
                                                                position: (1183, 28),
                                                               },
                                                               Raw {
                                                                content: "etc",
                                                                position: (1183, 40),
                                                               },
                                                               Expression {
                                                                expression: __StringParts(
                                                                 [
                                                                  Raw {
                                                                   content: "pam.d/",
                                                                  },
                                                                  Expression {
                                                                   expression: Variable {
                                                                    identifier: "name",
                                                                    position: (1183, 53),
                                                                   },
                                                                  },
                                                                 ],
                                                                ),
                                                               },
                                                               Raw {
                                                                content: "source",
                                                                position: (1183, 60),
                                                               },
                                                              ],
                                                             },
                                                             default: None,
                                                            },
                                                           },
                                                           Raw {
                                                            content: ",\n",
                                                           },
                                                          ],
                                                          position: (1183, 16),
                                                         },
                                                         position: (1183, 10),
                                                        },
                                                        FunctionApplication {
                                                         function: Variable {
                                                          identifier: "attrNames",
                                                          position: (1184, 10),
                                                         },
                                                         arguments: [
                                                          PropertyAccess {
                                                           expression: Variable {
                                                            identifier: "config",
                                                            position: (1184, 20),
                                                           },
                                                           attribute_path: AttributePath {
                                                            attributes: [
                                                             Raw {
                                                              content: "security",
                                                              position: (1184, 27),
                                                             },
                                                             Raw {
                                                              content: "pam",
                                                              position: (1184, 36),
                                                             },
                                                             Raw {
                                                              content: "services",
                                                              position: (1184, 40),
                                                             },
                                                            ],
                                                           },
                                                           default: None,
                                                          },
                                                         ],
                                                        },
                                                       ],
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "mr ",
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "getLib",
                                                           position: (1186, 12),
                                                          },
                                                          arguments: [
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "pkgs",
                                                             position: (1186, 19),
                                                            },
                                                            attribute_path: AttributePath {
                                                             attributes: [
                                                              Raw {
                                                               content: "pam",
                                                               position: (1186, 24),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "/lib/security/pam_filter/*,\nmr ",
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "getLib",
                                                           position: (1187, 12),
                                                          },
                                                          arguments: [
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "pkgs",
                                                             position: (1187, 19),
                                                            },
                                                            attribute_path: AttributePath {
                                                             attributes: [
                                                              Raw {
                                                               content: "pam",
                                                               position: (1187, 24),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "/lib/security/pam_*.so,\nr ",
                                                        },
                                                        Expression {
                                                         expression: FunctionApplication {
                                                          function: Variable {
                                                           identifier: "getLib",
                                                           position: (1188, 11),
                                                          },
                                                          arguments: [
                                                           PropertyAccess {
                                                            expression: Variable {
                                                             identifier: "pkgs",
                                                             position: (1188, 18),
                                                            },
                                                            attribute_path: AttributePath {
                                                             attributes: [
                                                              Raw {
                                                               content: "pam",
                                                               position: (1188, 23),
                                                              },
                                                             ],
                                                            },
                                                            default: None,
                                                           },
                                                          ],
                                                         },
                                                        },
                                                        Raw {
                                                         content: "/lib/security/,\n",
                                                        },
                                                       ],
                                                       position: (1185, 7),
                                                      },
                                                     ],
                                                     position: (1184, 50),
                                                    },
                                                    FunctionApplication {
                                                     function: Variable {
                                                      identifier: "optionalString",
                                                      position: (1190, 7),
                                                     },
                                                     arguments: [
                                                      Variable {
                                                       identifier: "use_ldap",
                                                       position: (1190, 22),
                                                      },
                                                      String {
                                                       parts: [
                                                        Raw {
                                                         content: "mr ",
                                                        },
                                                        Expression {
                                                         expression: Variable {
                                                          identifier: "pam_ldap",
                                                          position: (1191, 15),
                                                         },
                                                        },
                                                        Raw {
                                                         content: "/lib/security/pam_ldap.so,\n",
                                                        },
                                                       ],
                                                       position: (1190, 31),
                                                      },
                                                     ],
                                                    },
                                                   ],
                                                   position: (1189, 10),
                                                  },
                                                  FunctionApplication {
                                                   function: Variable {
                                                    identifier: "optionalString",
                                                    position: (1193, 7),
                                                   },
                                                   arguments: [
                                                    PropertyAccess {
                                                     expression: Variable {
                                                      identifier: "config",
                                                      position: (1193, 22),
                                                     },
                                                     attribute_path: AttributePath {
                                                      attributes: [
                                                       Raw {
                                                        content: "services",
                                                        position: (1193, 29),
                                                       },
                                                       Raw {
                                                        content: "sssd",
                                                        position: (1193, 38),
                                                       },
                                                       Raw {
                                                        content: "enable",
                                                        position: (1193, 43),
                                                       },
                                                      ],
                                                     },
                                                     default: None,
                                                    },
                                                    String {
                                                     parts: [
                                                      Raw {
                                                       content: "mr ",
                                                      },
                                                      Expression {
                                                       expression: PropertyAccess {
                                                        expression: Variable {
                                                         identifier: "pkgs",
                                                         position: (1194, 14),
                                                        },
                                                        attribute_path: AttributePath {
                                                         attributes: [
                                                          Raw {
                                                           content: "sssd",
                                                           position: (1194, 19),
                                                          },
                                                         ],
                                                        },
                                                        default: None,
                                                       },
                                                      },
                                                      Raw {
                                                       content: "/lib/security/pam_sss.so,\n",
                                                      },
                                                     ],
                                                     position: (1193, 50),
                                                    },
                                                   ],
                                                  },
                                                 ],
                                                 position: (1192, 10),
                                                },
                                                FunctionApplication {
                                                 function: Variable {
                                                  identifier: "optionalString",
                                                  position: (1196, 7),
                                                 },
                                                 arguments: [
                                                  PropertyAccess {
                                                   expression: Variable {
                                                    identifier: "config",
                                                    position: (1196, 22),
                                                   },
                                                   attribute_path: AttributePath {
                                                    attributes: [
                                                     Raw {
                                                      content: "krb5",
                                                      position: (1196, 29),
                                                     },
                                                     Raw {
                                                      content: "enable",
                                                      position: (1196, 34),
                                                     },
                                                    ],
                                                   },
                                                   default: None,
                                                  },
                                                  String {
                                                   parts: [
                                                    Raw {
                                                     content: "mr ",
                                                    },
                                                    Expression {
                                                     expression: Variable {
                                                      identifier: "pam_krb5",
                                                      position: (1197, 14),
                                                     },
                                                    },
                                                    Raw {
                                                     content: "/lib/security/pam_krb5.so,\nmr ",
                                                    },
                                                    Expression {
                                                     expression: Variable {
                                                      identifier: "pam_ccreds",
                                                      position: (1198, 14),
                                                     },
                                                    },
                                                    Raw {
                                                     content: "/lib/security/pam_ccreds.so,\n",
                                                    },
                                                   ],
                                                   position: (1196, 41),
                                                  },
                                                 ],
                                                },
                                               ],
                                               position: (1195, 10),
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "optionalString",
                                                position: (1200, 7),
                                               },
                                               arguments: [
                                                FunctionApplication {
                                                 function: Variable {
                                                  identifier: "isEnabled",
                                                  position: (1200, 23),
                                                 },
                                                 arguments: [
                                                  Function {
                                                   argument: Some(
                                                    "cfg",
                                                   ),
                                                   arguments: FunctionArguments {
                                                    arguments: [],
                                                    ellipsis: false,
                                                   },
                                                   definition: PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "cfg",
                                                     position: (1200, 39),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "googleOsLoginAccountVerification",
                                                       position: (1200, 43),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                   position: (1200, 34),
                                                  },
                                                 ],
                                                },
                                                String {
                                                 parts: [
                                                  Raw {
                                                   content: "mr ",
                                                  },
                                                  Expression {
                                                   expression: PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "pkgs",
                                                     position: (1201, 14),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "google-guest-oslogin",
                                                       position: (1201, 19),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                  },
                                                  Raw {
                                                   content: "/lib/security/pam_oslogin_login.so,\nmr ",
                                                  },
                                                  Expression {
                                                   expression: PropertyAccess {
                                                    expression: Variable {
                                                     identifier: "pkgs",
                                                     position: (1202, 14),
                                                    },
                                                    attribute_path: AttributePath {
                                                     attributes: [
                                                      Raw {
                                                       content: "google-guest-oslogin",
                                                       position: (1202, 19),
                                                      },
                                                     ],
                                                    },
                                                    default: None,
                                                   },
                                                  },
                                                  Raw {
                                                   content: "/lib/security/pam_oslogin_admin.so,\n",
                                                  },
                                                 ],
                                                 position: (1200, 78),
                                                },
                                               ],
                                              },
                                             ],
                                             position: (1199, 10),
                                            },
                                            FunctionApplication {
                                             function: Variable {
                                              identifier: "optionalString",
                                              position: (1204, 7),
                                             },
                                             arguments: [
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "isEnabled",
                                                position: (1204, 23),
                                               },
                                               arguments: [
                                                Function {
                                                 argument: Some(
                                                  "cfg",
                                                 ),
                                                 arguments: FunctionArguments {
                                                  arguments: [],
                                                  ellipsis: false,
                                                 },
                                                 definition: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "cfg",
                                                   position: (1204, 39),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "googleOsLoginAuthentication",
                                                     position: (1204, 43),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 position: (1204, 34),
                                                },
                                               ],
                                              },
                                              String {
                                               parts: [
                                                Raw {
                                                 content: "mr ",
                                                },
                                                Expression {
                                                 expression: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "pkgs",
                                                   position: (1205, 14),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "google-guest-oslogin",
                                                     position: (1205, 19),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                },
                                                Raw {
                                                 content: "/lib/security/pam_oslogin_login.so,\n",
                                                },
                                               ],
                                               position: (1204, 73),
                                              },
                                             ],
                                            },
                                           ],
                                           position: (1203, 10),
                                          },
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "optionalString",
                                            position: (1207, 7),
                                           },
                                           arguments: [
                                            BinaryOperation {
                                             operator: LogicalAnd,
                                             operands: [
                                              PropertyAccess {
                                               expression: Variable {
                                                identifier: "config",
                                                position: (1207, 23),
                                               },
                                               attribute_path: AttributePath {
                                                attributes: [
                                                 Raw {
                                                  content: "security",
                                                  position: (1207, 30),
                                                 },
                                                 Raw {
                                                  content: "pam",
                                                  position: (1207, 39),
                                                 },
                                                 Raw {
                                                  content: "enableSSHAgentAuth",
                                                  position: (1207, 43),
                                                 },
                                                ],
                                               },
                                               default: None,
                                              },
                                              FunctionApplication {
                                               function: Variable {
                                                identifier: "isEnabled",
                                                position: (1208, 25),
                                               },
                                               arguments: [
                                                Function {
                                                 argument: Some(
                                                  "cfg",
                                                 ),
                                                 arguments: FunctionArguments {
                                                  arguments: [],
                                                  ellipsis: false,
                                                 },
                                                 definition: PropertyAccess {
                                                  expression: Variable {
                                                   identifier: "cfg",
                                                   position: (1208, 41),
                                                  },
                                                  attribute_path: AttributePath {
                                                   attributes: [
                                                    Raw {
                                                     content: "sshAgentAuth",
                                                     position: (1208, 45),
                                                    },
                                                   ],
                                                  },
                                                  default: None,
                                                 },
                                                 position: (1208, 36),
                                                },
                                               ],
                                              },
                                             ],
                                             position: (1208, 22),
                                            },
                                            String {
                                             parts: [
                                              Raw {
                                               content: "mr ",
                                              },
                                              Expression {
                                               expression: PropertyAccess {
                                                expression: Variable {
                                                 identifier: "pkgs",
                                                 position: (1209, 14),
                                                },
                                                attribute_path: AttributePath {
                                                 attributes: [
                                                  Raw {
                                                   content: "pam_ssh_agent_auth",
                                                   position: (1209, 19),
                                                  },
                                                 ],
                                                },
                                                default: None,
                                               },
                                              },
                                              Raw {
                                               content: "/libexec/pam_ssh_agent_auth.so,\n",
                                              },
                                             ],
                                             position: (1208, 60),
                                            },
                                           ],
                                          },
                                         ],
                                         position: (1206, 10),
                                        },
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "optionalString",
                                          position: (1211, 7),
                                         },
                                         arguments: [
                                          FunctionApplication {
                                           function: Variable {
                                            identifier: "isEnabled",
                                            position: (1211, 23),
                                           },
                                           arguments: [
                                            Function {
                                             argument: Some(
                                              "cfg",
                                             ),
                                             arguments: FunctionArguments {
                                              arguments: [],
                                              ellipsis: false,
                                             },
                                             definition: PropertyAccess {
                                              expression: Variable {
                                               identifier: "cfg",
                                               position: (1211, 39),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "fprintAuth",
                                                 position: (1211, 43),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                             position: (1211, 34),
                                            },
                                           ],
                                          },
                                          String {
                                           parts: [
                                            Raw {
                                             content: "mr ",
                                            },
                                            Expression {
                                             expression: PropertyAccess {
                                              expression: Variable {
                                               identifier: "pkgs",
                                               position: (1212, 14),
                                              },
                                              attribute_path: AttributePath {
                                               attributes: [
                                                Raw {
                                                 content: "fprintd",
                                                 position: (1212, 19),
                                                },
                                               ],
                                              },
                                              default: None,
                                             },
                                            },
                                            Raw {
                                             content: "/lib/security/pam_fprintd.so,\n",
                                            },
                                           ],
                                           position: (1211, 56),
                                          },
                                         ],
                                        },
                                       ],
                                       position: (1210, 10),
                                      },
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "optionalString",
                                        position: (1214, 7),
                                       },
                                       arguments: [
                                        FunctionApplication {
                                         function: Variable {
                                          identifier: "isEnabled",
                                          position: (1214, 23),
                                         },
                                         arguments: [
                                          Function {
                                           argument: Some(
                                            "cfg",
                                           ),
                                           arguments: FunctionArguments {
                                            arguments: [],
                                            ellipsis: false,
                                           },
                                           definition: PropertyAccess {
                                            expression: Variable {
                                             identifier: "cfg",
                                             position: (1214, 39),
                                            },
                                            attribute_path: AttributePath {
                                             attributes: [
                                              Raw {
                                               content: "u2fAuth",
                                               position: (1214, 43),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                           position: (1214, 34),
                                          },
                                         ],
                                        },
                                        String {
                                         parts: [
                                          Raw {
                                           content: "mr ",
                                          },
                                          Expression {
                                           expression: PropertyAccess {
                                            expression: Variable {
                                             identifier: "pkgs",
                                             position: (1215, 14),
                                            },
                                            attribute_path: AttributePath {
                                             attributes: [
                                              Raw {
                                               content: "pam_u2f",
                                               position: (1215, 19),
                                              },
                                             ],
                                            },
                                            default: None,
                                           },
                                          },
                                          Raw {
                                           content: "/lib/security/pam_u2f.so,\n",
                                          },
                                         ],
                                         position: (1214, 53),
                                        },
                                       ],
                                      },
                                     ],
                                     position: (1213, 10),
                                    },
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "optionalString",
                                      position: (1217, 7),
                                     },
                                     arguments: [
                                      FunctionApplication {
                                       function: Variable {
                                        identifier: "isEnabled",
                                        position: (1217, 23),
                                       },
                                       arguments: [
                                        Function {
                                         argument: Some(
                                          "cfg",
                                         ),
                                         arguments: FunctionArguments {
                                          arguments: [],
                                          ellipsis: false,
                                         },
                                         definition: PropertyAccess {
                                          expression: Variable {
                                           identifier: "cfg",
                                           position: (1217, 39),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "usbAuth",
                                             position: (1217, 43),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                         position: (1217, 34),
                                        },
                                       ],
                                      },
                                      String {
                                       parts: [
                                        Raw {
                                         content: "mr ",
                                        },
                                        Expression {
                                         expression: PropertyAccess {
                                          expression: Variable {
                                           identifier: "pkgs",
                                           position: (1218, 14),
                                          },
                                          attribute_path: AttributePath {
                                           attributes: [
                                            Raw {
                                             content: "pam_usb",
                                             position: (1218, 19),
                                            },
                                           ],
                                          },
                                          default: None,
                                         },
                                        },
                                        Raw {
                                         content: "/lib/security/pam_usb.so,\n",
                                        },
                                       ],
                                       position: (1217, 53),
                                      },
                                     ],
                                    },
                                   ],
                                   position: (1216, 10),
                                  },
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "optionalString",
                                    position: (1220, 7),
                                   },
                                   arguments: [
                                    FunctionApplication {
                                     function: Variable {
                                      identifier: "isEnabled",
                                      position: (1220, 23),
                                     },
                                     arguments: [
                                      Function {
                                       argument: Some(
                                        "cfg",
                                       ),
                                       arguments: FunctionArguments {
                                        arguments: [],
                                        ellipsis: false,
                                       },
                                       definition: PropertyAccess {
                                        expression: Variable {
                                         identifier: "cfg",
                                         position: (1220, 39),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "usshAuth",
                                           position: (1220, 43),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                       position: (1220, 34),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "mr ",
                                      },
                                      Expression {
                                       expression: PropertyAccess {
                                        expression: Variable {
                                         identifier: "pkgs",
                                         position: (1221, 14),
                                        },
                                        attribute_path: AttributePath {
                                         attributes: [
                                          Raw {
                                           content: "pam_ussh",
                                           position: (1221, 19),
                                          },
                                         ],
                                        },
                                        default: None,
                                       },
                                      },
                                      Raw {
                                       content: "/lib/security/pam_ussh.so,\n",
                                      },
                                     ],
                                     position: (1220, 54),
                                    },
                                   ],
                                  },
                                 ],
                                 position: (1219, 10),
                                },
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "optionalString",
                                  position: (1223, 7),
                                 },
                                 arguments: [
                                  FunctionApplication {
                                   function: Variable {
                                    identifier: "isEnabled",
                                    position: (1223, 23),
                                   },
                                   arguments: [
                                    Function {
                                     argument: Some(
                                      "cfg",
                                     ),
                                     arguments: FunctionArguments {
                                      arguments: [],
                                      ellipsis: false,
                                     },
                                     definition: PropertyAccess {
                                      expression: Variable {
                                       identifier: "cfg",
                                       position: (1223, 39),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "oathAuth",
                                         position: (1223, 43),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                     position: (1223, 34),
                                    },
                                   ],
                                  },
                                  String {
                                   parts: [
                                    Raw {
                                     content: "\"mr ",
                                    },
                                    Expression {
                                     expression: PropertyAccess {
                                      expression: Variable {
                                       identifier: "pkgs",
                                       position: (1224, 15),
                                      },
                                      attribute_path: AttributePath {
                                       attributes: [
                                        Raw {
                                         content: "oathToolkit",
                                         position: (1224, 20),
                                        },
                                       ],
                                      },
                                      default: None,
                                     },
                                    },
                                    Raw {
                                     content: "/lib/security/pam_oath.so,\n",
                                    },
                                   ],
                                   position: (1223, 54),
                                  },
                                 ],
                                },
                               ],
                               position: (1222, 10),
                              },
                              FunctionApplication {
                               function: Variable {
                                identifier: "optionalString",
                                position: (1226, 7),
                               },
                               arguments: [
                                FunctionApplication {
                                 function: Variable {
                                  identifier: "isEnabled",
                                  position: (1226, 23),
                                 },
                                 arguments: [
                                  Function {
                                   argument: Some(
                                    "cfg",
                                   ),
                                   arguments: FunctionArguments {
                                    arguments: [],
                                    ellipsis: false,
                                   },
                                   definition: PropertyAccess {
                                    expression: Variable {
                                     identifier: "cfg",
                                     position: (1226, 39),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "yubicoAuth",
                                       position: (1226, 43),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                   position: (1226, 34),
                                  },
                                 ],
                                },
                                String {
                                 parts: [
                                  Raw {
                                   content: "mr ",
                                  },
                                  Expression {
                                   expression: PropertyAccess {
                                    expression: Variable {
                                     identifier: "pkgs",
                                     position: (1227, 14),
                                    },
                                    attribute_path: AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "yubico-pam",
                                       position: (1227, 19),
                                      },
                                     ],
                                    },
                                    default: None,
                                   },
                                  },
                                  Raw {
                                   content: "/lib/security/pam_yubico.so,\n",
                                  },
                                 ],
                                 position: (1226, 56),
                                },
                               ],
                              },
                             ],
                             position: (1225, 10),
                            },
                            FunctionApplication {
                             function: Variable {
                              identifier: "optionalString",
                              position: (1229, 7),
                             },
                             arguments: [
                              FunctionApplication {
                               function: Variable {
                                identifier: "isEnabled",
                                position: (1229, 23),
                               },
                               arguments: [
                                Function {
                                 argument: Some(
                                  "cfg",
                                 ),
                                 arguments: FunctionArguments {
                                  arguments: [],
                                  ellipsis: false,
                                 },
                                 definition: PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (1229, 39),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "duoSecurity",
                                     position: (1229, 43),
                                    },
                                    Raw {
                                     content: "enable",
                                     position: (1229, 55),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 position: (1229, 34),
                                },
                               ],
                              },
                              String {
                               parts: [
                                Raw {
                                 content: "mr ",
                                },
                                Expression {
                                 expression: PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (1230, 14),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "duo-unix",
                                     position: (1230, 19),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                },
                                Raw {
                                 content: "/lib/security/pam_duo.so,\n",
                                },
                               ],
                               position: (1229, 64),
                              },
                             ],
                            },
                           ],
                           position: (1228, 10),
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "optionalString",
                            position: (1232, 7),
                           },
                           arguments: [
                            FunctionApplication {
                             function: Variable {
                              identifier: "isEnabled",
                              position: (1232, 23),
                             },
                             arguments: [
                              Function {
                               argument: Some(
                                "cfg",
                               ),
                               arguments: FunctionArguments {
                                arguments: [],
                                ellipsis: false,
                               },
                               definition: PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (1232, 39),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "otpwAuth",
                                   position: (1232, 43),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               position: (1232, 34),
                              },
                             ],
                            },
                            String {
                             parts: [
                              Raw {
                               content: "mr ",
                              },
                              Expression {
                               expression: PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (1233, 14),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "otpw",
                                   position: (1233, 19),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              },
                              Raw {
                               content: "/lib/security/pam_otpw.so,\n",
                              },
                             ],
                             position: (1232, 54),
                            },
                           ],
                          },
                         ],
                         position: (1231, 10),
                        },
                        FunctionApplication {
                         function: Variable {
                          identifier: "optionalString",
                          position: (1235, 7),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "config",
                            position: (1235, 22),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "security",
                              position: (1235, 29),
                             },
                             Raw {
                              content: "pam",
                              position: (1235, 38),
                             },
                             Raw {
                              content: "enableEcryptfs",
                              position: (1235, 42),
                             },
                            ],
                           },
                           default: None,
                          },
                          String {
                           parts: [
                            Raw {
                             content: "mr ",
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (1236, 14),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "ecryptfs",
                                 position: (1236, 19),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/lib/security/pam_ecryptfs.so,\n",
                            },
                           ],
                           position: (1235, 57),
                          },
                         ],
                        },
                       ],
                       position: (1234, 10),
                      },
                      FunctionApplication {
                       function: Variable {
                        identifier: "optionalString",
                        position: (1238, 7),
                       },
                       arguments: [
                        FunctionApplication {
                         function: Variable {
                          identifier: "isEnabled",
                          position: (1238, 23),
                         },
                         arguments: [
                          Function {
                           argument: Some(
                            "cfg",
                           ),
                           arguments: FunctionArguments {
                            arguments: [],
                            ellipsis: false,
                           },
                           definition: PropertyAccess {
                            expression: Variable {
                             identifier: "cfg",
                             position: (1238, 39),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pamMount",
                               position: (1238, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                           position: (1238, 34),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Raw {
                           content: "mr ",
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (1239, 14),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "pam_mount",
                               position: (1239, 19),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/lib/security/pam_mount.so,\n",
                          },
                         ],
                         position: (1238, 54),
                        },
                       ],
                      },
                     ],
                     position: (1237, 10),
                    },
                    FunctionApplication {
                     function: Variable {
                      identifier: "optionalString",
                      position: (1241, 7),
                     },
                     arguments: [
                      FunctionApplication {
                       function: Variable {
                        identifier: "isEnabled",
                        position: (1241, 23),
                       },
                       arguments: [
                        Function {
                         argument: Some(
                          "cfg",
                         ),
                         arguments: FunctionArguments {
                          arguments: [],
                          ellipsis: false,
                         },
                         definition: PropertyAccess {
                          expression: Variable {
                           identifier: "cfg",
                           position: (1241, 39),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "enableGnomeKeyring",
                             position: (1241, 43),
                            },
                           ],
                          },
                          default: None,
                         },
                         position: (1241, 34),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "mr ",
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (1242, 14),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "gnome3",
                             position: (1242, 19),
                            },
                            Raw {
                             content: "gnome-keyring",
                             position: (1242, 26),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/lib/security/pam_gnome_keyring.so,\n",
                        },
                       ],
                       position: (1241, 64),
                      },
                     ],
                    },
                   ],
                   position: (1240, 10),
                  },
                  FunctionApplication {
                   function: Variable {
                    identifier: "optionalString",
                    position: (1244, 7),
                   },
                   arguments: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "isEnabled",
                      position: (1244, 23),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "cfg",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1244, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "startSession",
                           position: (1244, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                       position: (1244, 34),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mr ",
                      },
                      Expression {
                       expression: PropertyAccess {
                        expression: Variable {
                         identifier: "pkgs",
                         position: (1245, 14),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "systemd",
                           position: (1245, 19),
                          },
                         ],
                        },
                        default: None,
                       },
                      },
                      Raw {
                       content: "/lib/security/pam_systemd.so,\n",
                      },
                     ],
                     position: (1244, 58),
                    },
                   ],
                  },
                 ],
                 position: (1243, 10),
                },
                FunctionApplication {
                 function: Variable {
                  identifier: "optionalString",
                  position: (1247, 7),
                 },
                 arguments: [
                  BinaryOperation {
                   operator: LogicalAnd,
                   operands: [
                    FunctionApplication {
                     function: Variable {
                      identifier: "isEnabled",
                      position: (1247, 23),
                     },
                     arguments: [
                      Function {
                       argument: Some(
                        "cfg",
                       ),
                       arguments: FunctionArguments {
                        arguments: [],
                        ellipsis: false,
                       },
                       definition: PropertyAccess {
                        expression: Variable {
                         identifier: "cfg",
                         position: (1247, 39),
                        },
                        attribute_path: AttributePath {
                         attributes: [
                          Raw {
                           content: "enableAppArmor",
                           position: (1247, 43),
                          },
                         ],
                        },
                        default: None,
                       },
                       position: (1247, 34),
                      },
                     ],
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (1248, 25),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "security",
                        position: (1248, 32),
                       },
                       Raw {
                        content: "apparmor",
                        position: (1248, 41),
                       },
                       Raw {
                        content: "enable",
                        position: (1248, 50),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (1248, 22),
                  },
                  String {
                   parts: [
                    Raw {
                     content: "mr ",
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (1249, 14),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "apparmor-pam",
                         position: (1249, 19),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/lib/security/pam_apparmor.so,\n",
                    },
                   ],
                   position: (1248, 58),
                  },
                 ],
                },
               ],
               position: (1246, 10),
              },
              FunctionApplication {
               function: Variable {
                identifier: "optionalString",
                position: (1251, 7),
               },
               arguments: [
                FunctionApplication {
                 function: Variable {
                  identifier: "isEnabled",
                  position: (1251, 23),
                 },
                 arguments: [
                  Function {
                   argument: Some(
                    "cfg",
                   ),
                   arguments: FunctionArguments {
                    arguments: [],
                    ellipsis: false,
                   },
                   definition: PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (1251, 39),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "enableKwallet",
                       position: (1251, 43),
                      },
                     ],
                    },
                    default: None,
                   },
                   position: (1251, 34),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "mr ",
                  },
                  Expression {
                   expression: PropertyAccess {
                    expression: Variable {
                     identifier: "pkgs",
                     position: (1252, 14),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "plasma5Packages",
                       position: (1252, 19),
                      },
                      Raw {
                       content: "kwallet-pam",
                       position: (1252, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  },
                  Raw {
                   content: "/lib/security/pam_kwallet5.so,\n",
                  },
                 ],
                 position: (1251, 59),
                },
               ],
              },
             ],
             position: (1250, 10),
            },
            FunctionApplication {
             function: Variable {
              identifier: "optionalString",
              position: (1254, 7),
             },
             arguments: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (1254, 22),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "virtualisation",
                  position: (1254, 29),
                 },
                 Raw {
                  content: "lxc",
                  position: (1254, 44),
                 },
                 Raw {
                  content: "lxcfs",
                  position: (1254, 48),
                 },
                 Raw {
                  content: "enable",
                  position: (1254, 54),
                 },
                ],
               },
               default: None,
              },
              String {
               parts: [
                Raw {
                 content: "mr ",
                },
                Expression {
                 expression: PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (1255, 14),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lxc",
                     position: (1255, 19),
                    },
                   ],
                  },
                  default: None,
                 },
                },
                Raw {
                 content: "/lib/security/pam_cgfs.so\n",
                },
               ],
               position: (1254, 61),
              },
             ],
            },
           ],
           position: (1253, 10),
          },
          position: (1179, 53),
         },
        ),
       ],
       recursive: false,
       position: (1125, 12),
      },
     ),
    ],
    recursive: false,
    position: (727, 1),
   },
   position: (8, 1),
  },
  position: (6, 1),
 },
 position: (4, 1),
}