---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
   FunctionArgument {
    identifier: "config",
    default: None,
   },
  ],
  ellipsis: true,
 },
 definition: With {
  expression: Variable {
   identifier: "lib",
   position: (3, 6),
  },
  target: LetIn {
   bindings: [
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gunicorn",
        position: (5, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (5, 14),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "python3Packages",
         position: (5, 19),
        },
        Raw {
         content: "gunicorn",
         position: (5, 35),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "bepasty",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (6, 13),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "bepasty",
         position: (6, 18),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "gevent",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (7, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "python3Packages",
         position: (7, 17),
        },
        Raw {
         content: "gevent",
         position: (7, 33),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "python",
        position: (8, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "pkgs",
       position: (8, 12),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "python3Packages",
         position: (8, 17),
        },
        Raw {
         content: "python",
         position: (8, 33),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "cfg",
        position: (9, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (9, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (9, 16),
        },
        Raw {
         content: "bepasty",
         position: (9, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "user",
        position: (10, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "bepasty",
        position: (10, 11),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "group",
        position: (11, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "bepasty",
        position: (11, 12),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "default_home",
        position: (12, 3),
       },
      ],
     },
     String {
      parts: [
       Raw {
        content: "/var/lib/bepasty",
        position: (12, 19),
       },
      ],
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (15, 3),
        },
        Raw {
         content: "services",
         position: (15, 11),
        },
        Raw {
         content: "bepasty",
         position: (15, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (16, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkEnableOption",
           position: (16, 14),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "Bepasty servers",
              position: (16, 30),
             },
            ],
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "servers",
            position: (18, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (18, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (19, 7),
                },
               ],
              },
              Map {
               bindings: [],
               recursive: false,
               position: (19, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (20, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "configure a number of bepasty servers which will be started with\ngunicorn.\n",
                 position: (21, 1),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (24, 7),
                },
               ],
              },
              With {
               expression: Variable {
                identifier: "types",
                position: (24, 19),
               },
               target: FunctionApplication {
                function: Variable {
                 identifier: "attrsOf",
                 position: (24, 27),
                },
                arguments: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "submodule",
                   position: (24, 36),
                  },
                  arguments: [
                   Function {
                    argument: None,
                    arguments: FunctionArguments {
                     arguments: [
                      FunctionArgument {
                       identifier: "config",
                       default: None,
                      },
                     ],
                     ellipsis: true,
                    },
                    definition: Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "options",
                          position: (26, 9),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "bind",
                             position: (28, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (28, 18),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (29, 13),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (29, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (29, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (30, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Bind address to be used for this server.\n",
                                  position: (31, 1),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (33, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "0.0.0.0:8000",
                                  position: (33, 24),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (34, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "127.0.0.1:8000",
                                  position: (34, 24),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (28, 27),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "dataDir",
                             position: (37, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (37, 21),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (38, 13),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (38, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (38, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (39, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Path to the directory where the pastes will be saved to\n",
                                  position: (40, 1),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (42, 13),
                                 },
                                ],
                               },
                               BinaryOperation {
                                operator: Addition,
                                operands: [
                                 Variable {
                                  identifier: "default_home",
                                  position: (42, 23),
                                 },
                                 String {
                                  parts: [
                                   Raw {
                                    content: "/data",
                                    position: (42, 37),
                                   },
                                  ],
                                 },
                                ],
                                position: (42, 35),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (37, 30),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "defaultPermissions",
                             position: (45, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (45, 32),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (46, 13),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (46, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (46, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (47, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "default permissions for all unauthenticated accesses.\n",
                                  position: (48, 1),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (50, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "read,create,delete",
                                  position: (50, 24),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (51, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "read",
                                  position: (51, 24),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (45, 41),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "extraConfig",
                             position: (54, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (54, 25),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (55, 13),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (55, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "lines",
                                   position: (55, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (56, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Extra configuration for bepasty server to be appended on the\nconfiguration.\nsee https://bepasty-server.readthedocs.org/en/latest/quickstart.html#configuring-bepasty\nfor all options.\n",
                                  position: (57, 1),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (62, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "example",
                                  position: (63, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "PERMISSIONS = {\n  'myadminsecret': 'admin,list,create,read,delete',\n}\nMAX_ALLOWED_FILE_SIZE = 5 * 1000 * 1000\n",
                                  position: (64, 1),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (54, 34),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "secretKey",
                             position: (71, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (71, 23),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (72, 13),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (72, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (72, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (73, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "server secret for safe session cookies, must be set.\n\nWarning: this secret is stored in the WORLD-READABLE Nix store!\n\nIt's recommended to use <option>secretKeyFile</option>\nwhich takes precedence over <option>secretKey</option>.\n",
                                  position: (74, 1),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (81, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (71, 32),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "secretKeyFile",
                             position: (84, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (84, 27),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (85, 13),
                                 },
                                ],
                               },
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "types",
                                  position: (85, 20),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "nullOr",
                                    position: (85, 26),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "types",
                                   position: (85, 33),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "str",
                                     position: (85, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (86, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "null",
                                position: (86, 23),
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (87, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "A file that contains the server secret for safe session cookies, must be set.\n\n<option>secretKeyFile</option> takes precedence over <option>secretKey</option>.\n\nWarning: when <option>secretKey</option> is non-empty <option>secretKeyFile</option>\ndefaults to a file in the WORLD-READABLE Nix store containing that secret.\n",
                                  position: (88, 1),
                                 },
                                ],
                               },
                              ),
                             ],
                             recursive: false,
                             position: (84, 36),
                            },
                           ],
                          },
                         ),
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "workDir",
                             position: (97, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkOption",
                            position: (97, 21),
                           },
                           arguments: [
                            Map {
                             bindings: [
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "type",
                                  position: (98, 13),
                                 },
                                ],
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "types",
                                 position: (98, 20),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "str",
                                   position: (98, 26),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "description",
                                  position: (99, 13),
                                 },
                                ],
                               },
                               String {
                                parts: [
                                 Raw {
                                  content: "Path to the working directory (used for config and pidfile).\nDefaults to the users home directory.\n",
                                  position: (100, 1),
                                 },
                                ],
                               },
                              ),
                              KeyValue(
                               AttributePath {
                                attributes: [
                                 Raw {
                                  content: "default",
                                  position: (103, 13),
                                 },
                                ],
                               },
                               Variable {
                                identifier: "default_home",
                                position: (103, 23),
                               },
                              ),
                             ],
                             recursive: false,
                             position: (97, 30),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (26, 19),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "config",
                          position: (107, 9),
                         },
                        ],
                       },
                       Map {
                        bindings: [
                         KeyValue(
                          AttributePath {
                           attributes: [
                            Raw {
                             content: "secretKeyFile",
                             position: (108, 11),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: Variable {
                            identifier: "mkDefault",
                            position: (108, 27),
                           },
                           arguments: [
                            IfThenElse {
                             predicate: BinaryOperation {
                              operator: NotEqualTo,
                              operands: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "config",
                                 position: (109, 16),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "secretKey",
                                   position: (109, 23),
                                  },
                                 ],
                                },
                                default: None,
                               },
                               String {
                                parts: [],
                               },
                              ],
                              position: (109, 33),
                             },
                             then: FunctionApplication {
                              function: Variable {
                               identifier: "toString",
                               position: (110, 18),
                              },
                              arguments: [
                               FunctionApplication {
                                function: PropertyAccess {
                                 expression: Variable {
                                  identifier: "pkgs",
                                  position: (110, 28),
                                 },
                                 attribute_path: AttributePath {
                                  attributes: [
                                   Raw {
                                    content: "writeTextFile",
                                    position: (110, 33),
                                   },
                                  ],
                                 },
                                 default: None,
                                },
                                arguments: [
                                 Map {
                                  bindings: [
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "name",
                                       position: (111, 15),
                                      },
                                     ],
                                    },
                                    String {
                                     parts: [
                                      Raw {
                                       content: "bepasty-secret-key",
                                       position: (111, 23),
                                      },
                                     ],
                                    },
                                   ),
                                   KeyValue(
                                    AttributePath {
                                     attributes: [
                                      Raw {
                                       content: "text",
                                       position: (112, 15),
                                      },
                                     ],
                                    },
                                    PropertyAccess {
                                     expression: Variable {
                                      identifier: "config",
                                      position: (112, 22),
                                     },
                                     attribute_path: AttributePath {
                                      attributes: [
                                       Raw {
                                        content: "secretKey",
                                        position: (112, 29),
                                       },
                                      ],
                                     },
                                     default: None,
                                    },
                                   ),
                                  ],
                                  recursive: false,
                                  position: (110, 47),
                                 },
                                ],
                               },
                              ],
                             },
                             else_: Variable {
                              identifier: "null",
                              position: (114, 18),
                             },
                             position: (109, 13),
                            },
                           ],
                          },
                         ),
                        ],
                        recursive: false,
                        position: (107, 18),
                       },
                      ),
                     ],
                     recursive: false,
                     position: (24, 65),
                    },
                    position: (24, 47),
                   },
                  ],
                 },
                ],
               },
               position: (24, 14),
              },
             ),
            ],
            recursive: false,
            position: (18, 24),
           },
          ],
         },
        ),
       ],
       recursive: false,
       position: (15, 30),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (121, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkIf",
        position: (121, 12),
       },
       arguments: [
        PropertyAccess {
         expression: Variable {
          identifier: "cfg",
          position: (121, 17),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "enable",
            position: (121, 21),
           },
          ],
         },
         default: None,
        },
        Map {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "environment",
              position: (123, 5),
             },
             Raw {
              content: "systemPackages",
              position: (123, 17),
             },
            ],
           },
           List {
            elements: [
             Variable {
              identifier: "bepasty",
              position: (123, 36),
             },
            ],
            position: (123, 34),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "systemd",
              position: (126, 5),
             },
             Raw {
              content: "services",
              position: (126, 13),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "mapAttrs'",
             position: (126, 24),
            },
            arguments: [
             Function {
              argument: Some(
               "name",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: Function {
               argument: Some(
                "server",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: FunctionApplication {
                function: Variable {
                 identifier: "nameValuePair",
                 position: (127, 7),
                },
                arguments: [
                 String {
                  parts: [
                   Raw {
                    content: "bepasty-server-",
                    position: (127, 23),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "name",
                     position: (127, 40),
                    },
                   },
                   Raw {
                    content: "-gunicorn",
                    position: (127, 45),
                   },
                  ],
                 },
                 Map {
                  bindings: [
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "description",
                       position: (129, 11),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "Bepasty Server ",
                       position: (129, 26),
                      },
                      Expression {
                       expression: Variable {
                        identifier: "name",
                        position: (129, 43),
                       },
                      },
                     ],
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "wantedBy",
                       position: (130, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "multi-user.target",
                         position: (130, 25),
                        },
                       ],
                      },
                     ],
                     position: (130, 22),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "after",
                       position: (131, 11),
                      },
                     ],
                    },
                    List {
                     elements: [
                      String {
                       parts: [
                        Raw {
                         content: "network.target",
                         position: (131, 22),
                        },
                       ],
                      },
                     ],
                     position: (131, 19),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "restartIfChanged",
                       position: (132, 11),
                      },
                     ],
                    },
                    Variable {
                     identifier: "true",
                     position: (132, 30),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "environment",
                       position: (134, 11),
                      },
                     ],
                    },
                    LetIn {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "penv",
                          position: (135, 13),
                         },
                        ],
                       },
                       FunctionApplication {
                        function: PropertyAccess {
                         expression: Variable {
                          identifier: "python",
                          position: (135, 20),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "buildEnv",
                            position: (135, 27),
                           },
                           Raw {
                            content: "override",
                            position: (135, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                        arguments: [
                         Map {
                          bindings: [
                           KeyValue(
                            AttributePath {
                             attributes: [
                              Raw {
                               content: "extraLibs",
                               position: (136, 15),
                              },
                             ],
                            },
                            List {
                             elements: [
                              Variable {
                               identifier: "bepasty",
                               position: (136, 29),
                              },
                              Variable {
                               identifier: "gevent",
                               position: (136, 37),
                              },
                             ],
                             position: (136, 27),
                            },
                           ),
                          ],
                          recursive: false,
                          position: (135, 45),
                         },
                        ],
                       },
                      ),
                     ],
                     target: Map {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "BEPASTY_CONFIG",
                           position: (139, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "server",
                             position: (139, 33),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "workDir",
                               position: (139, 40),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/bepasty-",
                           position: (139, 48),
                          },
                          Expression {
                           expression: Variable {
                            identifier: "name",
                            position: (139, 59),
                           },
                          },
                          Raw {
                           content: ".conf",
                           position: (139, 64),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "PYTHONPATH",
                           position: (140, 13),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "penv",
                            position: (140, 28),
                           },
                          },
                          Raw {
                           content: "/",
                           position: (140, 33),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "python",
                             position: (140, 36),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "sitePackages",
                               position: (140, 43),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                          Raw {
                           content: "/",
                           position: (140, 56),
                          },
                         ],
                        },
                       ),
                      ],
                      recursive: false,
                      position: (138, 14),
                     },
                     position: (134, 25),
                    },
                   ),
                   KeyValue(
                    AttributePath {
                     attributes: [
                      Raw {
                       content: "serviceConfig",
                       position: (143, 11),
                      },
                     ],
                    },
                    Map {
                     bindings: [
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "Type",
                          position: (144, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Raw {
                          content: "simple",
                          position: (144, 21),
                         },
                        ],
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "PrivateTmp",
                          position: (145, 13),
                         },
                        ],
                       },
                       Variable {
                        identifier: "true",
                        position: (145, 26),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "ExecStartPre",
                          position: (146, 13),
                         },
                        ],
                       },
                       Assert {
                        expression: BinaryOperation {
                         operator: NotEqualTo,
                         operands: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "server",
                            position: (146, 35),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "secretKeyFile",
                              position: (146, 42),
                             },
                            ],
                           },
                           default: None,
                          },
                          Variable {
                           identifier: "null",
                           position: (146, 59),
                          },
                         ],
                         position: (146, 56),
                        },
                        target: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (146, 65),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "writeScript",
                             position: (146, 70),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "bepasty-server.",
                             position: (146, 83),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "name",
                              position: (146, 100),
                             },
                            },
                            Raw {
                             content: "-init",
                             position: (146, 105),
                            },
                           ],
                          },
                          String {
                           parts: [
                            Raw {
                             content: "#!/bin/sh\nmkdir -p \"",
                             position: (147, 1),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (148, 27),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "workDir",
                                 position: (148, 34),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\"\nmkdir -p \"",
                             position: (148, 42),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (149, 27),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "dataDir",
                                 position: (149, 34),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\"\nchown ",
                             position: (149, 42),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "user",
                              position: (150, 23),
                             },
                            },
                            Raw {
                             content: ":",
                             position: (150, 28),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "group",
                              position: (150, 31),
                             },
                            },
                            Raw {
                             content: " \"",
                             position: (150, 37),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (150, 41),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "workDir",
                                 position: (150, 48),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\" \"",
                             position: (150, 56),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (150, 61),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "dataDir",
                                 position: (150, 68),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\"\ncat > ",
                             position: (150, 76),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (151, 23),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "workDir",
                                 position: (151, 30),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/bepasty-",
                             position: (151, 38),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "name",
                              position: (151, 49),
                             },
                            },
                            Raw {
                             content: ".conf <<EOF\nSITENAME=\"",
                             position: (151, 54),
                            },
                            Expression {
                             expression: Variable {
                              identifier: "name",
                              position: (152, 27),
                             },
                            },
                            Raw {
                             content: "\"\nSTORAGE_FILESYSTEM_DIRECTORY=\"",
                             position: (152, 32),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (153, 47),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "dataDir",
                                 position: (153, 54),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\"\nSECRET_KEY=\"$(cat \"",
                             position: (153, 62),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (154, 36),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "secretKeyFile",
                                 position: (154, 43),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\")\"\nDEFAULT_PERMISSIONS=\"",
                             position: (154, 57),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (155, 38),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "defaultPermissions",
                                 position: (155, 45),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\"\n",
                             position: (155, 64),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "server",
                               position: (156, 17),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "extraConfig",
                                 position: (156, 24),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "\nEOF\n",
                             position: (156, 36),
                            },
                           ],
                          },
                         ],
                        },
                        position: (146, 28),
                       },
                      ),
                      KeyValue(
                       AttributePath {
                        attributes: [
                         Raw {
                          content: "ExecStart",
                          position: (159, 13),
                         },
                        ],
                       },
                       String {
                        parts: [
                         Expression {
                          expression: Variable {
                           identifier: "gunicorn",
                           position: (159, 29),
                          },
                         },
                         Raw {
                          content: "/bin/gunicorn bepasty.wsgi --name ",
                          position: (159, 38),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (159, 74),
                          },
                         },
                         Raw {
                          content: " \\\n              -u ",
                          position: (159, 79),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "user",
                           position: (160, 20),
                          },
                         },
                         Raw {
                          content: " \\\n              -g ",
                          position: (160, 25),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "group",
                           position: (161, 20),
                          },
                         },
                         Raw {
                          content: " \\\n              --workers 3 --log-level=info \\\n              --bind=",
                          position: (161, 26),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "server",
                            position: (163, 24),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "bind",
                              position: (163, 31),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: " \\\n              --pid ",
                          position: (163, 36),
                         },
                         Expression {
                          expression: PropertyAccess {
                           expression: Variable {
                            identifier: "server",
                            position: (164, 23),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "workDir",
                              position: (164, 30),
                             },
                            ],
                           },
                           default: None,
                          },
                         },
                         Raw {
                          content: "/gunicorn-",
                          position: (164, 38),
                         },
                         Expression {
                          expression: Variable {
                           identifier: "name",
                           position: (164, 50),
                          },
                         },
                         Raw {
                          content: ".pid \\\n              -k gevent\n            ",
                          position: (164, 55),
                         },
                        ],
                       },
                      ),
                     ],
                     recursive: false,
                     position: (143, 27),
                    },
                   ),
                  ],
                  recursive: false,
                  position: (128, 10),
                 },
                ],
               },
               position: (126, 41),
              },
              position: (126, 35),
             },
             PropertyAccess {
              expression: Variable {
               identifier: "cfg",
               position: (169, 7),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "servers",
                 position: (169, 11),
                },
               ],
              },
              default: None,
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (171, 5),
             },
             Raw {
              content: "users",
              position: (171, 11),
             },
             Expression {
              expression: Variable {
               identifier: "user",
               position: (171, 19),
              },
             },
            ],
           },
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "uid",
                 position: (172, 9),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (172, 15),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "ids",
                  position: (172, 22),
                 },
                 Raw {
                  content: "uids",
                  position: (172, 26),
                 },
                 Raw {
                  content: "bepasty",
                  position: (172, 31),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "group",
                 position: (173, 9),
                },
               ],
              },
              Variable {
               identifier: "group",
               position: (173, 17),
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "home",
                 position: (174, 9),
                },
               ],
              },
              Variable {
               identifier: "default_home",
               position: (174, 16),
              },
             ),
            ],
            recursive: false,
            position: (172, 7),
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "users",
              position: (177, 5),
             },
             Raw {
              content: "groups",
              position: (177, 11),
             },
             Expression {
              expression: Variable {
               identifier: "group",
               position: (177, 20),
              },
             },
             Raw {
              content: "gid",
              position: (177, 27),
             },
            ],
           },
           PropertyAccess {
            expression: Variable {
             identifier: "config",
             position: (177, 33),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "ids",
               position: (177, 40),
              },
              Raw {
               content: "gids",
               position: (177, 44),
              },
              Raw {
               content: "bepasty",
               position: (177, 49),
              },
             ],
            },
            default: None,
           },
          ),
         ],
         recursive: false,
         position: (121, 28),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (14, 1),
   },
   position: (4, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}