---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "pkgs",
    default: None,
   },
   FunctionArgument {
    identifier: "options",
    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: "cfg",
        position: (6, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "config",
       position: (6, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (6, 16),
        },
        Raw {
         content: "graphite",
         position: (6, 25),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "opt",
        position: (7, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "options",
       position: (7, 9),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "services",
         position: (7, 17),
        },
        Raw {
         content: "graphite",
         position: (7, 26),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "writeTextOrNull",
        position: (8, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "f",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "t",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "mapNullable",
         position: (8, 27),
        },
        arguments: [
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "pkgs",
            position: (8, 40),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "writeTextDir",
              position: (8, 45),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "f",
            position: (8, 58),
           },
          ],
         },
         Variable {
          identifier: "t",
          position: (8, 61),
         },
        ],
       },
       position: (8, 24),
      },
      position: (8, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "dataDir",
        position: (10, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "cfg",
       position: (10, 13),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "dataDir",
         position: (10, 17),
        },
       ],
      },
      default: None,
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "staticDir",
        position: (11, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Addition,
      operands: [
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (11, 15),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "dataDir",
           position: (11, 19),
          },
         ],
        },
        default: None,
       },
       String {
        parts: [
         Raw {
          content: "/static",
          position: (11, 30),
         },
        ],
       },
      ],
      position: (11, 27),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "graphiteLocalSettingsDir",
        position: (13, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (13, 30),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "runCommand",
          position: (13, 35),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "graphite_local_settings",
          position: (13, 47),
         },
        ],
       },
       Map {
        bindings: [
         Inherit(
          None,
          [
           Raw {
            content: "graphiteLocalSettings",
            position: (14, 15),
           },
          ],
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "preferLocalBuild",
             position: (15, 7),
            },
           ],
          },
          Variable {
           identifier: "true",
           position: (15, 26),
          },
         ),
        ],
        recursive: false,
        position: (13, 72),
       },
       String {
        parts: [
         Raw {
          content: "mkdir -p $out\nln -s $graphiteLocalSettings $out/graphite_local_settings.py\n",
          position: (17, 1),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "graphiteLocalSettings",
        position: (21, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (21, 27),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (21, 32),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "graphite_local_settings.py",
          position: (21, 43),
         },
        ],
       },
       BinaryOperation {
        operator: Addition,
        operands: [
         BinaryOperation {
          operator: Addition,
          operands: [
           String {
            parts: [
             Raw {
              content: "STATIC_ROOT = '",
              position: (22, 6),
             },
             Expression {
              expression: Variable {
               identifier: "staticDir",
               position: (22, 23),
              },
             },
             Raw {
              content: "'\n",
              position: (22, 33),
             },
            ],
           },
           FunctionApplication {
            function: Variable {
             identifier: "optionalString",
             position: (23, 5),
            },
            arguments: [
             BinaryOperation {
              operator: NotEqualTo,
              operands: [
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (23, 21),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "time",
                   position: (23, 28),
                  },
                  Raw {
                   content: "timeZone",
                   position: (23, 33),
                  },
                 ],
                },
                default: None,
               },
               Variable {
                identifier: "null",
                position: (23, 45),
               },
              ],
              position: (23, 42),
             },
             String {
              parts: [
               Raw {
                content: "TIME_ZONE = '",
                position: (23, 52),
               },
               Expression {
                expression: PropertyAccess {
                 expression: Variable {
                  identifier: "config",
                  position: (23, 67),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "time",
                    position: (23, 74),
                   },
                   Raw {
                    content: "timeZone",
                    position: (23, 79),
                   },
                  ],
                 },
                 default: None,
                },
               },
               Raw {
                content: "'\n",
                position: (23, 88),
               },
              ],
             },
            ],
           },
          ],
          position: (22, 38),
         },
         PropertyAccess {
          expression: Variable {
           identifier: "cfg",
           position: (24, 7),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "web",
             position: (24, 11),
            },
            Raw {
             content: "extraConfig",
             position: (24, 15),
            },
           ],
          },
          default: None,
         },
        ],
        position: (24, 5),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "graphiteApiConfig",
        position: (27, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (27, 23),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "writeText",
          position: (27, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "graphite-api.yaml",
          position: (27, 39),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "search_index: ",
          position: (28, 1),
         },
         Expression {
          expression: Variable {
           identifier: "dataDir",
           position: (28, 21),
          },
         },
         Raw {
          content: "/index\n",
          position: (28, 29),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (29, 7),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "config",
                position: (29, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "time",
                  position: (29, 30),
                 },
                 Raw {
                  content: "timeZone",
                  position: (29, 35),
                 },
                ],
               },
               default: None,
              },
              Variable {
               identifier: "null",
               position: (29, 47),
              },
             ],
             position: (29, 44),
            },
            String {
             parts: [
              Raw {
               content: "time_zone: ",
               position: (29, 54),
              },
              Expression {
               expression: PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (29, 67),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "time",
                   position: (29, 74),
                  },
                  Raw {
                   content: "timeZone",
                   position: (29, 79),
                  },
                 ],
                },
                default: None,
               },
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (29, 90),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (30, 7),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (30, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "api",
                  position: (30, 27),
                 },
                 Raw {
                  content: "finders",
                  position: (30, 31),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (30, 42),
              },
             ],
             position: (30, 39),
            },
            String {
             parts: [
              Raw {
               content: "finders:",
               position: (30, 47),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (30, 57),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatMapStringsSep",
            position: (31, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (31, 28),
              },
             ],
            },
            Function {
             argument: Some(
              "f",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: Addition,
              operands: [
               String {
                parts: [
                 Raw {
                  content: "  - ",
                  position: (31, 37),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "f",
                 position: (31, 45),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "moduleName",
                   position: (31, 47),
                  },
                 ],
                },
                default: None,
               },
              ],
              position: (31, 43),
             },
             position: (31, 33),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (31, 59),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "api",
                position: (31, 63),
               },
               Raw {
                content: "finders",
                position: (31, 67),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (31, 75),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (32, 7),
           },
           arguments: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (32, 23),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "api",
                  position: (32, 27),
                 },
                 Raw {
                  content: "functions",
                  position: (32, 31),
                 },
                ],
               },
               default: None,
              },
              List {
               elements: [],
               position: (32, 44),
              },
             ],
             position: (32, 41),
            },
            String {
             parts: [
              Raw {
               content: "functions:",
               position: (32, 49),
              },
             ],
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (32, 61),
         },
         Expression {
          expression: FunctionApplication {
           function: Variable {
            identifier: "concatMapStringsSep",
            position: (33, 7),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "\n",
               position: (33, 28),
              },
             ],
            },
            Function {
             argument: Some(
              "f",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: Addition,
              operands: [
               String {
                parts: [
                 Raw {
                  content: "  - ",
                  position: (33, 37),
                 },
                ],
               },
               Variable {
                identifier: "f",
                position: (33, 45),
               },
              ],
              position: (33, 43),
             },
             position: (33, 33),
            },
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (33, 48),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "api",
                position: (33, 52),
               },
               Raw {
                content: "functions",
                position: (33, 56),
               },
              ],
             },
             default: None,
            },
           ],
          },
         },
         Raw {
          content: "\n",
          position: (33, 66),
         },
         Expression {
          expression: PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (34, 7),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "api",
              position: (34, 11),
             },
             Raw {
              content: "extraConfig",
              position: (34, 15),
             },
            ],
           },
           default: None,
          },
         },
         Raw {
          content: "\n",
          position: (34, 27),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "seyrenConfig",
        position: (37, 3),
       },
      ],
     },
     BinaryOperation {
      operator: Update,
      operands: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "SEYREN_URL",
             position: (38, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (38, 18),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "seyren",
              position: (38, 22),
             },
             Raw {
              content: "seyrenUrl",
              position: (38, 29),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "MONGO_URL",
             position: (39, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (39, 17),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "seyren",
              position: (39, 21),
             },
             Raw {
              content: "mongoUrl",
              position: (39, 28),
             },
            ],
           },
           default: None,
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "GRAPHITE_URL",
             position: (40, 5),
            },
           ],
          },
          PropertyAccess {
           expression: Variable {
            identifier: "cfg",
            position: (40, 20),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "seyren",
              position: (40, 24),
             },
             Raw {
              content: "graphiteUrl",
              position: (40, 31),
             },
            ],
           },
           default: None,
          },
         ),
        ],
        recursive: false,
        position: (37, 18),
       },
       PropertyAccess {
        expression: Variable {
         identifier: "cfg",
         position: (41, 8),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "seyren",
           position: (41, 12),
          },
          Raw {
           content: "extraConfig",
           position: (41, 19),
          },
         ],
        },
        default: None,
       },
      ],
      position: (41, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "configDir",
        position: (43, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "pkgs",
        position: (43, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "buildEnv",
          position: (43, 20),
         },
        ],
       },
       default: None,
      },
      arguments: [
       Map {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "name",
             position: (44, 5),
            },
           ],
          },
          String {
           parts: [
            Raw {
             content: "graphite-config",
             position: (44, 13),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "paths",
             position: (45, 5),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lists",
             position: (45, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "filter",
               position: (45, 19),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Function {
             argument: Some(
              "el",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: NotEqualTo,
              operands: [
               Variable {
                identifier: "el",
                position: (45, 31),
               },
               Variable {
                identifier: "null",
                position: (45, 37),
               },
              ],
              position: (45, 34),
             },
             position: (45, 27),
            },
            List {
             elements: [
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (46, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "carbon.conf",
                   position: (46, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (46, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (46, 42),
                   },
                   Raw {
                    content: "config",
                    position: (46, 49),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (47, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "storage-aggregation.conf",
                   position: (47, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (47, 51),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (47, 55),
                   },
                   Raw {
                    content: "storageAggregation",
                    position: (47, 62),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (48, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "storage-schemas.conf",
                   position: (48, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (48, 47),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (48, 51),
                   },
                   Raw {
                    content: "storageSchemas",
                    position: (48, 58),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (49, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "blacklist.conf",
                   position: (49, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (49, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (49, 45),
                   },
                   Raw {
                    content: "blacklist",
                    position: (49, 52),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (50, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "whitelist.conf",
                   position: (50, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (50, 41),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (50, 45),
                   },
                   Raw {
                    content: "whitelist",
                    position: (50, 52),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (51, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "rewrite-rules.conf",
                   position: (51, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (51, 45),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (51, 49),
                   },
                   Raw {
                    content: "rewriteRules",
                    position: (51, 56),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (52, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "relay-rules.conf",
                   position: (52, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (52, 43),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (52, 47),
                   },
                   Raw {
                    content: "relayRules",
                    position: (52, 54),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "writeTextOrNull",
                position: (53, 8),
               },
               arguments: [
                String {
                 parts: [
                  Raw {
                   content: "aggregation-rules.conf",
                   position: (53, 25),
                  },
                 ],
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (53, 49),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (53, 53),
                   },
                   Raw {
                    content: "aggregationRules",
                    position: (53, 60),
                   },
                  ],
                 },
                 default: None,
                },
               ],
              },
             ],
             position: (45, 43),
            },
           ],
          },
         ),
        ],
        recursive: false,
        position: (43, 29),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "carbonOpts",
        position: (57, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "name",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: With {
       expression: PropertyAccess {
        expression: Variable {
         identifier: "config",
         position: (57, 27),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "ids",
           position: (57, 34),
          },
         ],
        },
        default: None,
       },
       target: String {
        parts: [
         Raw {
          content: "--nodaemon --syslog --prefix=",
          position: (58, 1),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (58, 36),
          },
         },
         Raw {
          content: " --pidfile /run/",
          position: (58, 41),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (58, 59),
          },
         },
         Raw {
          content: "/",
          position: (58, 64),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (58, 67),
          },
         },
         Raw {
          content: ".pid ",
          position: (58, 72),
         },
         Expression {
          expression: Variable {
           identifier: "name",
           position: (58, 79),
          },
         },
         Raw {
          content: "\n",
          position: (58, 84),
         },
        ],
       },
       position: (57, 22),
      },
      position: (57, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "carbonEnv",
        position: (61, 3),
       },
      ],
     },
     Map {
      bindings: [
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "PYTHONPATH",
           position: (62, 5),
          },
         ],
        },
        LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "cenv",
              position: (63, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (63, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "python3",
                position: (63, 19),
               },
               Raw {
                content: "buildEnv",
                position: (63, 27),
               },
               Raw {
                content: "override",
                position: (63, 36),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Map {
              bindings: [
               KeyValue(
                AttributePath {
                 attributes: [
                  Raw {
                   content: "extraLibs",
                   position: (64, 9),
                  },
                 ],
                },
                List {
                 elements: [
                  PropertyAccess {
                   expression: Variable {
                    identifier: "pkgs",
                    position: (64, 23),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "python3Packages",
                      position: (64, 28),
                     },
                     Raw {
                      content: "carbon",
                      position: (64, 44),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (64, 21),
                },
               ),
              ],
              recursive: false,
              position: (63, 45),
             },
            ],
           },
          ),
         ],
         target: String {
          parts: [
           Expression {
            expression: Variable {
             identifier: "cenv",
             position: (66, 11),
            },
           },
           Raw {
            content: "/",
            position: (66, 16),
           },
           Expression {
            expression: PropertyAccess {
             expression: Variable {
              identifier: "pkgs",
              position: (66, 19),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "python3",
                position: (66, 24),
               },
               Raw {
                content: "sitePackages",
                position: (66, 32),
               },
              ],
             },
             default: None,
            },
           },
          ],
         },
         position: (62, 18),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "GRAPHITE_ROOT",
           position: (67, 5),
          },
         ],
        },
        Variable {
         identifier: "dataDir",
         position: (67, 21),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "GRAPHITE_CONF_DIR",
           position: (68, 5),
          },
         ],
        },
        Variable {
         identifier: "configDir",
         position: (68, 25),
        },
       ),
       KeyValue(
        AttributePath {
         attributes: [
          Raw {
           content: "GRAPHITE_STORAGE_DIR",
           position: (69, 5),
          },
         ],
        },
        Variable {
         identifier: "dataDir",
         position: (69, 28),
        },
       ),
      ],
      recursive: false,
      position: (61, 15),
     },
    ),
   ],
   target: Map {
    bindings: [
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "imports",
         position: (74, 3),
        },
       ],
      },
      List {
       elements: [
        FunctionApplication {
         function: Variable {
          identifier: "mkRemovedOptionModule",
          position: (75, 6),
         },
         arguments: [
          List {
           elements: [
            String {
             parts: [
              Raw {
               content: "services",
               position: (75, 30),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "graphite",
               position: (75, 41),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "pager",
               position: (75, 52),
              },
             ],
            },
           ],
           position: (75, 28),
          },
          String {
           parts: [],
          },
         ],
        },
       ],
       position: (74, 13),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "options",
         position: (80, 3),
        },
        Raw {
         content: "services",
         position: (80, 11),
        },
        Raw {
         content: "graphite",
         position: (80, 20),
        },
       ],
      },
      Map {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "dataDir",
            position: (81, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "mkOption",
           position: (81, 15),
          },
          arguments: [
           Map {
            bindings: [
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "type",
                 position: (82, 7),
                },
               ],
              },
              PropertyAccess {
               expression: Variable {
                identifier: "types",
                position: (82, 14),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "path",
                  position: (82, 20),
                 },
                ],
               },
               default: None,
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "default",
                 position: (83, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "/var/db/graphite",
                 position: (83, 18),
                },
               ],
              },
             ),
             KeyValue(
              AttributePath {
               attributes: [
                Raw {
                 content: "description",
                 position: (84, 7),
                },
               ],
              },
              String {
               parts: [
                Raw {
                 content: "Data directory for graphite.\n",
                 position: (85, 1),
                },
               ],
              },
             ),
            ],
            recursive: false,
            position: (81, 24),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "web",
            position: (89, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (90, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (90, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (91, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable graphite web frontend.",
                    position: (91, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (92, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (92, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (93, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (93, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (93, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (90, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listenAddress",
               position: (96, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (96, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (97, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Graphite web frontend listen address.",
                    position: (97, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (98, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "127.0.0.1",
                    position: (98, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (99, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (99, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (99, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (96, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (102, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (102, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (103, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Graphite web frontend port.",
                    position: (103, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (104, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8080,
                  position: (104, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (105, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (105, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (105, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (102, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (108, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (108, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (109, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (109, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (109, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (110, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (111, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Graphite webapp settings. See:\n<link xlink:href=\"http://graphite.readthedocs.io/en/latest/config-local-settings.html\"/>\n",
                    position: (112, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (108, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (89, 11),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "api",
            position: (118, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (119, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (119, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (120, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable graphite api. Graphite api is lightweight alternative\nto graphite web, with api and without dashboard. It's advised to use\ngrafana as alternative dashboard and influxdb as alternative to\ngraphite carbon.\n\nFor more information visit\n<link xlink:href=\"https://graphite-api.readthedocs.org/en/latest/\"/>\n",
                    position: (121, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (129, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (129, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (130, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (130, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (130, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (119, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "finders",
               position: (133, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (133, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (134, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of finder plugins to load.",
                    position: (134, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (135, 9),
                   },
                  ],
                 },
                 List {
                  elements: [],
                  position: (135, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (136, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (136, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "[ pkgs.python3Packages.influxgraph ]",
                      position: (136, 38),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (137, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (137, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (137, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (137, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "package",
                       position: (137, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (133, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "functions",
               position: (140, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (140, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (141, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "List of functions to load.",
                    position: (141, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (142, 9),
                   },
                  ],
                 },
                 List {
                  elements: [
                   String {
                    parts: [
                     Raw {
                      content: "graphite_api.functions.SeriesFunctions",
                      position: (143, 12),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "graphite_api.functions.PieFunctions",
                      position: (144, 12),
                     },
                    ],
                   },
                  ],
                  position: (142, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (146, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (146, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "listOf",
                      position: (146, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (146, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (146, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (140, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "listenAddress",
               position: (149, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (149, 23),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (150, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Graphite web service listen address.",
                    position: (150, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (151, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "127.0.0.1",
                    position: (151, 20),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (152, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (152, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (152, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (149, 32),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (155, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (155, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (156, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Graphite api service port.",
                    position: (156, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (157, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8080,
                  position: (157, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (158, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (158, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (158, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (155, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "package",
               position: (161, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (161, 17),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (162, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Package to use for graphite api.",
                    position: (162, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (163, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (163, 19),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "python3Packages",
                     position: (163, 24),
                    },
                    Raw {
                     content: "graphite_api",
                     position: (163, 40),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (164, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (164, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "pkgs.python3Packages.graphite_api",
                      position: (164, 42),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (165, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (165, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "package",
                     position: (165, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (161, 26),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (168, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (168, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (169, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra configuration for graphite api.",
                    position: (169, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (170, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "whisper:\n  directories:\n      - ",
                    position: (171, 1),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "dataDir",
                     position: (173, 21),
                    },
                   },
                   Raw {
                    content: "/whisper\n",
                    position: (173, 29),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (175, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (175, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "",
                      position: (176, 1),
                     },
                     Raw {
                      content: "''",
                      position: (176, 11),
                     },
                     Raw {
                      content: "\n  whisper:\n    directories:\n      - ",
                      position: (176, 14),
                     },
                     Raw {
                      content: "$",
                      position: (179, 19),
                     },
                     Raw {
                      content: "{config.",
                      position: (179, 22),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (179, 32),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "dataDir",
                          position: (179, 36),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/whisper\n",
                      position: (179, 44),
                     },
                     Raw {
                      content: "''",
                      position: (180, 11),
                     },
                     Raw {
                      content: "\n",
                      position: (180, 14),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (182, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "allowed_origins:\n  - dashboard.example.com\ncheat_times: true\ninfluxdb:\n  host: localhost\n  port: 8086\n  user: influxdb\n  pass: influxdb\n  db: metrics\ncache:\n  CACHE_TYPE: 'filesystem'\n  CACHE_DIR: '/tmp/graphite-api-cache'\n",
                    position: (183, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (196, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (196, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "lines",
                     position: (196, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (168, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (118, 11),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "carbon",
            position: (200, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (201, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (201, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (202, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Content of carbon configuration file.",
                    position: (202, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (203, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "[cache]\n# Listen on localhost by default for security reasons\nUDP_RECEIVER_INTERFACE = 127.0.0.1\nPICKLE_RECEIVER_INTERFACE = 127.0.0.1\nLINE_RECEIVER_INTERFACE = 127.0.0.1\nCACHE_QUERY_INTERFACE = 127.0.0.1\n# Do not log every update\nLOG_UPDATES = False\nLOG_CACHE_HITS = False\n",
                    position: (204, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (214, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (214, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (214, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (201, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableCache",
               position: (217, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (217, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (218, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable carbon cache, the graphite storage daemon.",
                    position: (218, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (219, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (219, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (220, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (220, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (220, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (217, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "storageAggregation",
               position: (223, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (223, 28),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (224, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Defines how to aggregate data to lower-precision retentions.",
                    position: (224, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (225, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (225, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (226, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (226, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (226, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (226, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (226, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (227, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "[all_min]\npattern = \\.min$\nxFilesFactor = 0.1\naggregationMethod = min\n",
                    position: (228, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (223, 37),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "storageSchemas",
               position: (235, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (235, 24),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (236, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Defines retention rates for storing metrics.",
                    position: (236, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (237, 9),
                   },
                  ],
                 },
                 String {
                  parts: [],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (238, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (238, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (238, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (238, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (238, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (239, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "[apache_busyWorkers]\npattern = ^servers\\.www.*\\.workers\\.busyWorkers$\nretentions = 15s:7d,1m:21d,15m:5y\n",
                    position: (240, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (235, 33),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "blacklist",
               position: (246, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (246, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (247, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Any metrics received which match one of the experssions will be dropped.",
                    position: (247, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (248, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (248, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (249, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (249, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (249, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (249, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (249, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (250, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "^some\\.noisy\\.metric\\.prefix\\..*",
                    position: (250, 20),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (246, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "whitelist",
               position: (253, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (253, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (254, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Only metrics received which match one of the experssions will be persisted.",
                    position: (254, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (255, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (255, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (256, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (256, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (256, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (256, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (256, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (257, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: ".*",
                    position: (257, 20),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (253, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "rewriteRules",
               position: (260, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (260, 22),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (261, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Regular expression patterns that can be used to rewrite metric names\nin a search and replace fashion.\n",
                    position: (262, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (265, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (265, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (266, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (266, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (266, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (266, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (266, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (267, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "[post]\n_sum$ =\n_avg$ =\n",
                    position: (268, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (260, 31),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableRelay",
               position: (274, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (274, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (275, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable carbon relay, the carbon replication and sharding service.",
                    position: (275, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (276, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (276, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (277, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (277, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (277, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (274, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "relayRules",
               position: (280, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (280, 20),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (281, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Relay rules are used to send certain metrics to a certain backend.",
                    position: (281, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (282, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (282, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (283, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (283, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (283, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (283, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (283, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (284, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "[example]\npattern = ^mydata\\.foo\\..+\nservers = 10.1.2.3, 10.1.2.4:2004, myserver.mydomain.com\n",
                    position: (285, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (280, 29),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enableAggregator",
               position: (291, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (291, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (292, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable carbon aggregator, the carbon buffering service.",
                    position: (292, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (293, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (293, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (294, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (294, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (294, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (291, 35),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "aggregationRules",
               position: (297, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (297, 26),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (298, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Defines if and how received metrics will be aggregated.",
                    position: (298, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (299, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "null",
                  position: (299, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (300, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (300, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "nullOr",
                      position: (300, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (300, 29),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (300, 35),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (301, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "<env>.applications.<app>.all.requests (60) = sum <env>.applications.<app>.*.requests\n<env>.applications.<app>.all.latency (60) = avg <env>.applications.<app>.*.latency\n",
                    position: (302, 1),
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (297, 35),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (200, 14),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "seyren",
            position: (308, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (309, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (309, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (310, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Whether to enable seyren service.",
                    position: (310, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (311, 9),
                   },
                  ],
                 },
                 Variable {
                  identifier: "false",
                  position: (311, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (312, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (312, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "bool",
                     position: (312, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (309, 25),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "port",
               position: (315, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (315, 14),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (316, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Seyren listening port.",
                    position: (316, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (317, 9),
                   },
                  ],
                 },
                 Int {
                  value: 8081,
                  position: (317, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (318, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (318, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "int",
                     position: (318, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (315, 23),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "seyrenUrl",
               position: (321, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (321, 19),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (322, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "http://localhost:",
                    position: (322, 20),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (322, 39),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (322, 48),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "seyren",
                          position: (322, 52),
                         },
                         Raw {
                          content: "port",
                          position: (322, 59),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                   Raw {
                    content: "/",
                    position: (322, 64),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (323, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (323, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"http://localhost:",
                      position: (323, 43),
                     },
                     Raw {
                      content: "$",
                      position: (323, 61),
                     },
                     Raw {
                      content: "{toString config.",
                      position: (323, 64),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (323, 83),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "seyren",
                          position: (323, 87),
                         },
                         Raw {
                          content: "port",
                          position: (323, 94),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}/\"",
                      position: (323, 99),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (324, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Host where seyren is accessible.",
                    position: (324, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (325, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (325, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (325, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (321, 28),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "graphiteUrl",
               position: (328, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (328, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (329, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "http://",
                    position: (329, 20),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (329, 29),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "web",
                        position: (329, 33),
                       },
                       Raw {
                        content: "listenAddress",
                        position: (329, 37),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: ":",
                    position: (329, 51),
                   },
                   Expression {
                    expression: FunctionApplication {
                     function: Variable {
                      identifier: "toString",
                      position: (329, 54),
                     },
                     arguments: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (329, 63),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "web",
                          position: (329, 67),
                         },
                         Raw {
                          content: "port",
                          position: (329, 71),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                    },
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (330, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (330, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"http://",
                      position: (330, 43),
                     },
                     Raw {
                      content: "$",
                      position: (330, 51),
                     },
                     Raw {
                      content: "{config.",
                      position: (330, 54),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (330, 64),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "web",
                          position: (330, 68),
                         },
                         Raw {
                          content: "listenAddress",
                          position: (330, 72),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}:",
                      position: (330, 86),
                     },
                     Raw {
                      content: "$",
                      position: (330, 88),
                     },
                     Raw {
                      content: "{toString config.",
                      position: (330, 91),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "opt",
                        position: (330, 110),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "web",
                          position: (330, 114),
                         },
                         Raw {
                          content: "port",
                          position: (330, 118),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "}\"",
                      position: (330, 123),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (331, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Host where graphite service runs.",
                    position: (331, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (332, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (332, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (332, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (328, 30),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "mongoUrl",
               position: (335, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (335, 18),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (336, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "mongodb://",
                    position: (336, 20),
                   },
                   Expression {
                    expression: PropertyAccess {
                     expression: Variable {
                      identifier: "config",
                      position: (336, 32),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "services",
                        position: (336, 39),
                       },
                       Raw {
                        content: "mongodb",
                        position: (336, 48),
                       },
                       Raw {
                        content: "bind_ip",
                        position: (336, 56),
                       },
                      ],
                     },
                     default: None,
                    },
                   },
                   Raw {
                    content: ":27017/seyren",
                    position: (336, 64),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "defaultText",
                    position: (337, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (337, 23),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "\"mongodb://",
                      position: (337, 43),
                     },
                     Raw {
                      content: "$",
                      position: (337, 54),
                     },
                     Raw {
                      content: "{config.services.mongodb.bind_ip}:27017/seyren\"",
                      position: (337, 57),
                     },
                    ],
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (338, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Mongodb connection string.",
                    position: (338, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (339, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (339, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "str",
                     position: (339, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (335, 27),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "extraConfig",
               position: (342, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (342, 21),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (343, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (343, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (344, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Extra seyren configuration. See\n<link xlink:href='https://github.com/scobal/seyren#config' />\n",
                    position: (345, 1),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (348, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "types",
                    position: (348, 16),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "attrsOf",
                      position: (348, 22),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   PropertyAccess {
                    expression: Variable {
                     identifier: "types",
                     position: (348, 30),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "str",
                       position: (348, 36),
                      },
                     ],
                    },
                    default: None,
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "example",
                    position: (349, 9),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: Variable {
                   identifier: "literalExpression",
                   position: (349, 19),
                  },
                  arguments: [
                   String {
                    parts: [
                     Raw {
                      content: "{\n  GRAPHITE_USERNAME = \"user\";\n  GRAPHITE_PASSWORD = \"pass\";\n}\n",
                      position: (350, 1),
                     },
                    ],
                   },
                  ],
                 },
                ),
               ],
               recursive: false,
               position: (342, 30),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (308, 14),
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "beacon",
            position: (358, 5),
           },
          ],
         },
         Map {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "enable",
               position: (359, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkEnableOption",
              position: (359, 16),
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "graphite beacon",
                 position: (359, 32),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "config",
               position: (361, 7),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "mkOption",
              position: (361, 16),
             },
             arguments: [
              Map {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "description",
                    position: (362, 9),
                   },
                  ],
                 },
                 String {
                  parts: [
                   Raw {
                    content: "Graphite beacon configuration.",
                    position: (362, 24),
                   },
                  ],
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "default",
                    position: (363, 9),
                   },
                  ],
                 },
                 Map {
                  bindings: [],
                  recursive: false,
                  position: (363, 19),
                 },
                ),
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "type",
                    position: (364, 9),
                   },
                  ],
                 },
                 PropertyAccess {
                  expression: Variable {
                   identifier: "types",
                   position: (364, 16),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "attrs",
                     position: (364, 22),
                    },
                   ],
                  },
                  default: None,
                 },
                ),
               ],
               recursive: false,
               position: (361, 25),
              },
             ],
            },
           ),
          ],
          recursive: false,
          position: (358, 14),
         },
        ),
       ],
       recursive: false,
       position: (80, 31),
      },
     ),
     KeyValue(
      AttributePath {
       attributes: [
        Raw {
         content: "config",
         position: (371, 3),
        },
       ],
      },
      FunctionApplication {
       function: Variable {
        identifier: "mkMerge",
        position: (371, 12),
       },
       arguments: [
        List {
         elements: [
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (372, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (372, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "carbon",
                position: (372, 15),
               },
               Raw {
                content: "enableCache",
                position: (372, 22),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (373, 7),
                 },
                 Raw {
                  content: "services",
                  position: (373, 15),
                 },
                 Raw {
                  content: "carbonCache",
                  position: (373, 24),
                 },
                ],
               },
               LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (373, 42),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "carbon-cache",
                     position: (373, 50),
                    },
                   ],
                  },
                 ),
                ],
                target: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (374, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Graphite Data Storage Backend",
                      position: (374, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "wantedBy",
                      position: (375, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (375, 23),
                       },
                      ],
                     },
                    ],
                    position: (375, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "after",
                      position: (376, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (376, 20),
                       },
                      ],
                     },
                    ],
                    position: (376, 17),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "environment",
                      position: (377, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "carbonEnv",
                    position: (377, 23),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (378, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "RuntimeDirectory",
                         position: (379, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "name",
                       position: (379, 30),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (380, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (380, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python3Packages",
                             position: (380, 31),
                            },
                            Raw {
                             content: "twisted",
                             position: (380, 47),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/twistd ",
                         position: (380, 55),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "carbonOpts",
                           position: (380, 69),
                          },
                          arguments: [
                           Variable {
                            identifier: "name",
                            position: (380, 80),
                           },
                          ],
                         },
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (381, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (381, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Group",
                         position: (382, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (382, 20),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "PermissionsStartOnly",
                         position: (383, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "true",
                       position: (383, 34),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "PIDFile",
                         position: (384, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/run/",
                         position: (384, 20),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "name",
                          position: (384, 27),
                         },
                        },
                        Raw {
                         content: "/",
                         position: (384, 32),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "name",
                          position: (384, 35),
                         },
                        },
                        Raw {
                         content: ".pid",
                         position: (384, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (378, 25),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "preStart",
                      position: (386, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "install -dm0700 -o graphite -g graphite ",
                      position: (387, 1),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (387, 53),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "dataDir",
                          position: (387, 57),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "\ninstall -dm0700 -o graphite -g graphite ",
                      position: (387, 65),
                     },
                     Expression {
                      expression: PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (388, 53),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "dataDir",
                          position: (388, 57),
                         },
                        ],
                       },
                       default: None,
                      },
                     },
                     Raw {
                      content: "/whisper\n",
                      position: (388, 65),
                     },
                    ],
                   },
                  ),
                 ],
                 recursive: false,
                 position: (373, 68),
                },
                position: (373, 38),
               },
              ),
             ],
             recursive: false,
             position: (372, 34),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (393, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (393, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "carbon",
                position: (393, 15),
               },
               Raw {
                content: "enableAggregator",
                position: (393, 22),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (394, 7),
                 },
                 Raw {
                  content: "services",
                  position: (394, 15),
                 },
                 Raw {
                  content: "carbonAggregator",
                  position: (394, 24),
                 },
                ],
               },
               LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (394, 47),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "carbon-aggregator",
                     position: (394, 55),
                    },
                   ],
                  },
                 ),
                ],
                target: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "enable",
                      position: (395, 9),
                     },
                    ],
                   },
                   PropertyAccess {
                    expression: Variable {
                     identifier: "cfg",
                     position: (395, 18),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "carbon",
                       position: (395, 22),
                      },
                      Raw {
                       content: "enableAggregator",
                       position: (395, 29),
                      },
                     ],
                    },
                    default: None,
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (396, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Carbon Data Aggregator",
                      position: (396, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "wantedBy",
                      position: (397, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (397, 23),
                       },
                      ],
                     },
                    ],
                    position: (397, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "after",
                      position: (398, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (398, 20),
                       },
                      ],
                     },
                    ],
                    position: (398, 17),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "environment",
                      position: (399, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "carbonEnv",
                    position: (399, 23),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (400, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "RuntimeDirectory",
                         position: (401, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "name",
                       position: (401, 30),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (402, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (402, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python3Packages",
                             position: (402, 31),
                            },
                            Raw {
                             content: "twisted",
                             position: (402, 47),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/twistd ",
                         position: (402, 55),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "carbonOpts",
                           position: (402, 69),
                          },
                          arguments: [
                           Variable {
                            identifier: "name",
                            position: (402, 80),
                           },
                          ],
                         },
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (403, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (403, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Group",
                         position: (404, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (404, 20),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "PIDFile",
                         position: (405, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/run/",
                         position: (405, 20),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "name",
                          position: (405, 27),
                         },
                        },
                        Raw {
                         content: "/",
                         position: (405, 32),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "name",
                          position: (405, 35),
                         },
                        },
                        Raw {
                         content: ".pid",
                         position: (405, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (400, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (394, 78),
                },
                position: (394, 43),
               },
              ),
             ],
             recursive: false,
             position: (393, 39),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (410, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (410, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "carbon",
                position: (410, 15),
               },
               Raw {
                content: "enableRelay",
                position: (410, 22),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (411, 7),
                 },
                 Raw {
                  content: "services",
                  position: (411, 15),
                 },
                 Raw {
                  content: "carbonRelay",
                  position: (411, 24),
                 },
                ],
               },
               LetIn {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "name",
                     position: (411, 42),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "carbon-relay",
                     position: (411, 50),
                    },
                   ],
                  },
                 ),
                ],
                target: Map {
                 bindings: [
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "description",
                      position: (412, 9),
                     },
                    ],
                   },
                   String {
                    parts: [
                     Raw {
                      content: "Carbon Data Relay",
                      position: (412, 24),
                     },
                    ],
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "wantedBy",
                      position: (413, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "multi-user.target",
                        position: (413, 23),
                       },
                      ],
                     },
                    ],
                    position: (413, 20),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "after",
                      position: (414, 9),
                     },
                    ],
                   },
                   List {
                    elements: [
                     String {
                      parts: [
                       Raw {
                        content: "network.target",
                        position: (414, 20),
                       },
                      ],
                     },
                    ],
                    position: (414, 17),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "environment",
                      position: (415, 9),
                     },
                    ],
                   },
                   Variable {
                    identifier: "carbonEnv",
                    position: (415, 23),
                   },
                  ),
                  KeyValue(
                   AttributePath {
                    attributes: [
                     Raw {
                      content: "serviceConfig",
                      position: (416, 9),
                     },
                    ],
                   },
                   Map {
                    bindings: [
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "RuntimeDirectory",
                         position: (417, 11),
                        },
                       ],
                      },
                      Variable {
                       identifier: "name",
                       position: (417, 30),
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "ExecStart",
                         position: (418, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (418, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python3Packages",
                             position: (418, 31),
                            },
                            Raw {
                             content: "twisted",
                             position: (418, 47),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                        Raw {
                         content: "/bin/twistd ",
                         position: (418, 55),
                        },
                        Expression {
                         expression: FunctionApplication {
                          function: Variable {
                           identifier: "carbonOpts",
                           position: (418, 69),
                          },
                          arguments: [
                           Variable {
                            identifier: "name",
                            position: (418, 80),
                           },
                          ],
                         },
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "User",
                         position: (419, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (419, 19),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "Group",
                         position: (420, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "graphite",
                         position: (420, 20),
                        },
                       ],
                      },
                     ),
                     KeyValue(
                      AttributePath {
                       attributes: [
                        Raw {
                         content: "PIDFile",
                         position: (421, 11),
                        },
                       ],
                      },
                      String {
                       parts: [
                        Raw {
                         content: "/run/",
                         position: (421, 20),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "name",
                          position: (421, 27),
                         },
                        },
                        Raw {
                         content: "/",
                         position: (421, 32),
                        },
                        Expression {
                         expression: Variable {
                          identifier: "name",
                          position: (421, 35),
                         },
                        },
                        Raw {
                         content: ".pid",
                         position: (421, 40),
                        },
                       ],
                      },
                     ),
                    ],
                    recursive: false,
                    position: (416, 25),
                   },
                  ),
                 ],
                 recursive: false,
                 position: (411, 68),
                },
                position: (411, 38),
               },
              ),
             ],
             recursive: false,
             position: (410, 34),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (426, 6),
           },
           arguments: [
            BinaryOperation {
             operator: LogicalOr,
             operands: [
              BinaryOperation {
               operator: LogicalOr,
               operands: [
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (426, 12),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (426, 16),
                   },
                   Raw {
                    content: "enableCache",
                    position: (426, 23),
                   },
                  ],
                 },
                 default: None,
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (426, 38),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "carbon",
                    position: (426, 42),
                   },
                   Raw {
                    content: "enableAggregator",
                    position: (426, 49),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (426, 35),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (426, 69),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "carbon",
                  position: (426, 73),
                 },
                 Raw {
                  content: "enableRelay",
                  position: (426, 80),
                 },
                ],
               },
               default: None,
              },
             ],
             position: (426, 66),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "environment",
                  position: (427, 7),
                 },
                 Raw {
                  content: "systemPackages",
                  position: (427, 19),
                 },
                ],
               },
               List {
                elements: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (428, 9),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "python3Packages",
                     position: (428, 14),
                    },
                    Raw {
                     content: "carbon",
                     position: (428, 30),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (427, 36),
               },
              ),
             ],
             recursive: false,
             position: (426, 93),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (432, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (432, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "web",
                position: (432, 15),
               },
               Raw {
                content: "enable",
                position: (432, 19),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (433, 7),
                 },
                 Raw {
                  content: "services",
                  position: (433, 15),
                 },
                 Raw {
                  content: "graphiteWeb",
                  position: (433, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (434, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Graphite Web Interface",
                     position: (434, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (435, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (435, 23),
                      },
                     ],
                    },
                   ],
                   position: (435, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (436, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (436, 20),
                      },
                     ],
                    },
                   ],
                   position: (436, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "path",
                     position: (437, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    PropertyAccess {
                     expression: Variable {
                      identifier: "pkgs",
                      position: (437, 18),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "perl",
                        position: (437, 23),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (437, 16),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "environment",
                     position: (438, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PYTHONPATH",
                        position: (439, 11),
                       },
                      ],
                     },
                     LetIn {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "penv",
                           position: (440, 15),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (440, 22),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python3",
                             position: (440, 27),
                            },
                            Raw {
                             content: "buildEnv",
                             position: (440, 35),
                            },
                            Raw {
                             content: "override",
                             position: (440, 44),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "extraLibs",
                                position: (441, 17),
                               },
                              ],
                             },
                             List {
                              elements: [
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "pkgs",
                                 position: (442, 19),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "python3Packages",
                                   position: (442, 24),
                                  },
                                  Raw {
                                   content: "graphite-web",
                                   position: (442, 40),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ],
                              position: (441, 29),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (440, 53),
                          },
                         ],
                        },
                       ),
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "penvPack",
                           position: (445, 15),
                          },
                         ],
                        },
                        String {
                         parts: [
                          Expression {
                           expression: Variable {
                            identifier: "penv",
                            position: (445, 29),
                           },
                          },
                          Raw {
                           content: "/",
                           position: (445, 34),
                          },
                          Expression {
                           expression: PropertyAccess {
                            expression: Variable {
                             identifier: "pkgs",
                             position: (445, 37),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "python3",
                               position: (445, 42),
                              },
                              Raw {
                               content: "sitePackages",
                               position: (445, 50),
                              },
                             ],
                            },
                            default: None,
                           },
                          },
                         ],
                        },
                       ),
                      ],
                      target: FunctionApplication {
                       function: Variable {
                        identifier: "concatStringsSep",
                        position: (446, 16),
                       },
                       arguments: [
                        String {
                         parts: [
                          Raw {
                           content: ":",
                           position: (446, 34),
                          },
                         ],
                        },
                        List {
                         elements: [
                          String {
                           parts: [
                            Expression {
                             expression: Variable {
                              identifier: "graphiteLocalSettingsDir",
                              position: (447, 21),
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Expression {
                             expression: Variable {
                              identifier: "penvPack",
                              position: (448, 21),
                             },
                            },
                           ],
                          },
                          String {
                           parts: [
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (450, 21),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "python3Packages",
                                 position: (450, 26),
                                },
                                Raw {
                                 content: "pycairo",
                                 position: (450, 42),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                            Raw {
                             content: "/",
                             position: (450, 50),
                            },
                            Expression {
                             expression: PropertyAccess {
                              expression: Variable {
                               identifier: "pkgs",
                               position: (450, 53),
                              },
                              attribute_path: AttributePath {
                               attributes: [
                                Raw {
                                 content: "python3",
                                 position: (450, 58),
                                },
                                Raw {
                                 content: "sitePackages",
                                 position: (450, 66),
                                },
                               ],
                              },
                              default: None,
                             },
                            },
                           ],
                          },
                         ],
                         position: (446, 37),
                        },
                       ],
                      },
                      position: (439, 24),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "DJANGO_SETTINGS_MODULE",
                        position: (452, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite.settings",
                        position: (452, 37),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "GRAPHITE_SETTINGS_MODULE",
                        position: (453, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite_local_settings",
                        position: (453, 39),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "GRAPHITE_CONF_DIR",
                        position: (454, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "configDir",
                      position: (454, 31),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "GRAPHITE_STORAGE_DIR",
                        position: (455, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "dataDir",
                      position: (455, 34),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "LD_LIBRARY_PATH",
                        position: (456, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (456, 32),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "cairo",
                            position: (456, 37),
                           },
                           Raw {
                            content: "out",
                            position: (456, 43),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/lib",
                        position: (456, 47),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (438, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (458, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (459, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "",
                        position: (460, 1),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (460, 15),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "python3Packages",
                            position: (460, 20),
                           },
                           Raw {
                            content: "waitress-django",
                            position: (460, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/waitress-serve-django \\\n  --host=",
                        position: (460, 52),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (461, 24),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "web",
                            position: (461, 28),
                           },
                           Raw {
                            content: "listenAddress",
                            position: (461, 32),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: " --port=",
                        position: (461, 46),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toString",
                          position: (461, 56),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (461, 65),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "web",
                              position: (461, 69),
                             },
                             Raw {
                              content: "port",
                              position: (461, 73),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "\n",
                        position: (461, 78),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "User",
                        position: (463, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (463, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Group",
                        position: (464, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (464, 20),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PermissionsStartOnly",
                        position: (465, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (465, 34),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (458, 25),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (467, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "if ! test -e ",
                     position: (468, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (468, 26),
                     },
                    },
                    Raw {
                     content: "/db-created; then\n  mkdir -p ",
                     position: (468, 34),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (469, 24),
                     },
                    },
                    Raw {
                     content: "/{whisper/,log/webapp/}\n  chmod 0700 ",
                     position: (469, 32),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (470, 26),
                     },
                    },
                    Raw {
                     content: "/{whisper/,log/webapp/}\n\n  ",
                     position: (470, 34),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (472, 15),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "python3Packages",
                         position: (472, 20),
                        },
                        Raw {
                         content: "django",
                         position: (472, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/django-admin.py migrate --noinput\n\n  chown -R graphite:graphite ",
                     position: (472, 43),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (474, 42),
                     },
                    },
                    Raw {
                     content: "\n\n  touch ",
                     position: (474, 50),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (476, 21),
                     },
                    },
                    Raw {
                     content: "/db-created\nfi\n\n# Only collect static files when graphite_web changes.\nif ! [ \"",
                     position: (476, 29),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (480, 21),
                     },
                    },
                    Raw {
                     content: "/current_graphite_web\" -ef \"",
                     position: (480, 29),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (480, 59),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "python3Packages",
                         position: (480, 64),
                        },
                        Raw {
                         content: "graphite-web",
                         position: (480, 80),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\" ]; then\n  mkdir -p ",
                     position: (480, 93),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "staticDir",
                      position: (481, 24),
                     },
                    },
                    Raw {
                     content: "\n  ",
                     position: (481, 34),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (482, 15),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "python3Packages",
                         position: (482, 20),
                        },
                        Raw {
                         content: "django",
                         position: (482, 36),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/bin/django-admin.py collectstatic  --noinput --clear\n  chown -R graphite:graphite ",
                     position: (482, 43),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "staticDir",
                      position: (483, 42),
                     },
                    },
                    Raw {
                     content: "\n  ln -sfT \"",
                     position: (483, 52),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "pkgs",
                       position: (484, 24),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "python3Packages",
                         position: (484, 29),
                        },
                        Raw {
                         content: "graphite-web",
                         position: (484, 45),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\" \"",
                     position: (484, 58),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (484, 63),
                     },
                    },
                    Raw {
                     content: "/current_graphite_web\"\nfi\n",
                     position: (484, 71),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (433, 38),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "environment",
                  position: (489, 7),
                 },
                 Raw {
                  content: "systemPackages",
                  position: (489, 19),
                 },
                ],
               },
               List {
                elements: [
                 PropertyAccess {
                  expression: Variable {
                   identifier: "pkgs",
                   position: (489, 38),
                  },
                  attribute_path: AttributePath {
                   attributes: [
                    Raw {
                     content: "python3Packages",
                     position: (489, 43),
                    },
                    Raw {
                     content: "graphite-web",
                     position: (489, 59),
                    },
                   ],
                  },
                  default: None,
                 },
                ],
                position: (489, 36),
               },
              ),
             ],
             recursive: false,
             position: (432, 27),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (492, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (492, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "api",
                position: (492, 15),
               },
               Raw {
                content: "enable",
                position: (492, 19),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (493, 7),
                 },
                 Raw {
                  content: "services",
                  position: (493, 15),
                 },
                 Raw {
                  content: "graphiteApi",
                  position: (493, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (494, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Graphite Api Interface",
                     position: (494, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (495, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (495, 23),
                      },
                     ],
                    },
                   ],
                   position: (495, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (496, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (496, 20),
                      },
                     ],
                    },
                   ],
                   position: (496, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "environment",
                     position: (497, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PYTHONPATH",
                        position: (498, 11),
                       },
                      ],
                     },
                     LetIn {
                      bindings: [
                       KeyValue(
                        AttributePath {
                         attributes: [
                          Raw {
                           content: "aenv",
                           position: (499, 15),
                          },
                         ],
                        },
                        FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (499, 22),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python3",
                             position: (499, 27),
                            },
                            Raw {
                             content: "buildEnv",
                             position: (499, 35),
                            },
                            Raw {
                             content: "override",
                             position: (499, 44),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          Map {
                           bindings: [
                            KeyValue(
                             AttributePath {
                              attributes: [
                               Raw {
                                content: "extraLibs",
                                position: (500, 17),
                               },
                              ],
                             },
                             BinaryOperation {
                              operator: Concatenation,
                              operands: [
                               List {
                                elements: [
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "cfg",
                                   position: (500, 31),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "api",
                                     position: (500, 35),
                                    },
                                    Raw {
                                     content: "package",
                                     position: (500, 39),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (500, 47),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "cairo",
                                     position: (500, 52),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                 PropertyAccess {
                                  expression: Variable {
                                   identifier: "pkgs",
                                   position: (500, 58),
                                  },
                                  attribute_path: AttributePath {
                                   attributes: [
                                    Raw {
                                     content: "python3Packages",
                                     position: (500, 63),
                                    },
                                    Raw {
                                     content: "cffi",
                                     position: (500, 79),
                                    },
                                   ],
                                  },
                                  default: None,
                                 },
                                ],
                                position: (500, 29),
                               },
                               PropertyAccess {
                                expression: Variable {
                                 identifier: "cfg",
                                 position: (500, 89),
                                },
                                attribute_path: AttributePath {
                                 attributes: [
                                  Raw {
                                   content: "api",
                                   position: (500, 93),
                                  },
                                  Raw {
                                   content: "finders",
                                   position: (500, 97),
                                  },
                                 ],
                                },
                                default: None,
                               },
                              ],
                              position: (500, 86),
                             },
                            ),
                           ],
                           recursive: false,
                           position: (499, 53),
                          },
                         ],
                        },
                       ),
                      ],
                      target: String {
                       parts: [
                        Expression {
                         expression: Variable {
                          identifier: "aenv",
                          position: (502, 19),
                         },
                        },
                        Raw {
                         content: "/",
                         position: (502, 24),
                        },
                        Expression {
                         expression: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (502, 27),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "python3",
                             position: (502, 32),
                            },
                            Raw {
                             content: "sitePackages",
                             position: (502, 40),
                            },
                           ],
                          },
                          default: None,
                         },
                        },
                       ],
                      },
                      position: (498, 24),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "GRAPHITE_API_CONFIG",
                        position: (503, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "graphiteApiConfig",
                      position: (503, 33),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "LD_LIBRARY_PATH",
                        position: (504, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (504, 32),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "cairo",
                            position: (504, 37),
                           },
                           Raw {
                            content: "out",
                            position: (504, 43),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/lib",
                        position: (504, 47),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (497, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (506, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (507, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "",
                        position: (508, 1),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (508, 15),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "python3Packages",
                            position: (508, 20),
                           },
                           Raw {
                            content: "waitress",
                            position: (508, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/waitress-serve \\\n--host=",
                        position: (508, 45),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (509, 22),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "api",
                            position: (509, 26),
                           },
                           Raw {
                            content: "listenAddress",
                            position: (509, 30),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: " --port=",
                        position: (509, 44),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toString",
                          position: (509, 54),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (509, 63),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "api",
                              position: (509, 67),
                             },
                             Raw {
                              content: "port",
                              position: (509, 71),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                       },
                       Raw {
                        content: " \\\ngraphite_api.app:app\n",
                        position: (509, 76),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "User",
                        position: (512, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (512, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Group",
                        position: (513, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (513, 20),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "PermissionsStartOnly",
                        position: (514, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "true",
                      position: (514, 34),
                     },
                    ),
                   ],
                   recursive: false,
                   position: (506, 25),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (516, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "if ! test -e ",
                     position: (517, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (517, 26),
                     },
                    },
                    Raw {
                     content: "/db-created; then\n  mkdir -p ",
                     position: (517, 34),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (518, 24),
                     },
                    },
                    Raw {
                     content: "/cache/\n  chmod 0700 ",
                     position: (518, 32),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (519, 26),
                     },
                    },
                    Raw {
                     content: "/cache/\n\n  chown graphite:graphite ",
                     position: (519, 34),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (521, 39),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (521, 43),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "\n  chown -R graphite:graphite ",
                     position: (521, 51),
                    },
                    Expression {
                     expression: PropertyAccess {
                      expression: Variable {
                       identifier: "cfg",
                       position: (522, 42),
                      },
                      attribute_path: AttributePath {
                       attributes: [
                        Raw {
                         content: "dataDir",
                         position: (522, 46),
                        },
                       ],
                      },
                      default: None,
                     },
                    },
                    Raw {
                     content: "/cache\n\n  touch ",
                     position: (522, 54),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (524, 21),
                     },
                    },
                    Raw {
                     content: "/db-created\nfi\n",
                     position: (524, 29),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (493, 38),
               },
              ),
             ],
             recursive: false,
             position: (492, 26),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (530, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (530, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "seyren",
                position: (530, 15),
               },
               Raw {
                content: "enable",
                position: (530, 22),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (531, 7),
                 },
                 Raw {
                  content: "services",
                  position: (531, 15),
                 },
                 Raw {
                  content: "seyren",
                  position: (531, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (532, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Graphite Alerting Dashboard",
                     position: (532, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (533, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (533, 23),
                      },
                     ],
                    },
                   ],
                   position: (533, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "after",
                     position: (534, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "network.target",
                       position: (534, 20),
                      },
                     ],
                    },
                    String {
                     parts: [
                      Raw {
                       content: "mongodb.service",
                       position: (534, 37),
                      },
                     ],
                    },
                   ],
                   position: (534, 17),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "environment",
                     position: (535, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "seyrenConfig",
                   position: (535, 23),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (536, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (537, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (537, 26),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "seyren",
                            position: (537, 31),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/seyren -httpPort ",
                        position: (537, 38),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: Variable {
                          identifier: "toString",
                          position: (537, 62),
                         },
                         arguments: [
                          PropertyAccess {
                           expression: Variable {
                            identifier: "cfg",
                            position: (537, 71),
                           },
                           attribute_path: AttributePath {
                            attributes: [
                             Raw {
                              content: "seyren",
                              position: (537, 75),
                             },
                             Raw {
                              content: "port",
                              position: (537, 82),
                             },
                            ],
                           },
                           default: None,
                          },
                         ],
                        },
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "WorkingDirectory",
                        position: (538, 11),
                       },
                      ],
                     },
                     Variable {
                      identifier: "dataDir",
                      position: (538, 30),
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "User",
                        position: (539, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (539, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Group",
                        position: (540, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (540, 20),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (536, 25),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "preStart",
                     position: (542, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "if ! test -e ",
                     position: (543, 1),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (543, 26),
                     },
                    },
                    Raw {
                     content: "/db-created; then\n  mkdir -p ",
                     position: (543, 34),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (544, 24),
                     },
                    },
                    Raw {
                     content: "\n  chown graphite:graphite ",
                     position: (544, 32),
                    },
                    Expression {
                     expression: Variable {
                      identifier: "dataDir",
                      position: (545, 39),
                     },
                    },
                    Raw {
                     content: "\nfi\n",
                     position: (545, 47),
                    },
                   ],
                  },
                 ),
                ],
                recursive: false,
                position: (531, 33),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "services",
                  position: (550, 7),
                 },
                 Raw {
                  content: "mongodb",
                  position: (550, 16),
                 },
                 Raw {
                  content: "enable",
                  position: (550, 24),
                 },
                ],
               },
               FunctionApplication {
                function: Variable {
                 identifier: "mkDefault",
                 position: (550, 33),
                },
                arguments: [
                 Variable {
                  identifier: "true",
                  position: (550, 43),
                 },
                ],
               },
              ),
             ],
             recursive: false,
             position: (530, 29),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (553, 6),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "cfg",
              position: (553, 11),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "beacon",
                position: (553, 15),
               },
               Raw {
                content: "enable",
                position: (553, 22),
               },
              ],
             },
             default: None,
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "systemd",
                  position: (554, 7),
                 },
                 Raw {
                  content: "services",
                  position: (554, 15),
                 },
                 Raw {
                  content: "graphite-beacon",
                  position: (554, 24),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (555, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Grpahite Beacon Alerting Daemon",
                     position: (555, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "wantedBy",
                     position: (556, 9),
                    },
                   ],
                  },
                  List {
                   elements: [
                    String {
                     parts: [
                      Raw {
                       content: "multi-user.target",
                       position: (556, 23),
                      },
                     ],
                    },
                   ],
                   position: (556, 20),
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "serviceConfig",
                     position: (557, 9),
                    },
                   ],
                  },
                  Map {
                   bindings: [
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "ExecStart",
                        position: (558, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "",
                        position: (559, 1),
                       },
                       Expression {
                        expression: PropertyAccess {
                         expression: Variable {
                          identifier: "pkgs",
                          position: (559, 15),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "python3Packages",
                            position: (559, 20),
                           },
                           Raw {
                            content: "graphite_beacon",
                            position: (559, 36),
                           },
                          ],
                         },
                         default: None,
                        },
                       },
                       Raw {
                        content: "/bin/graphite-beacon \\\n  --config=",
                        position: (559, 52),
                       },
                       Expression {
                        expression: FunctionApplication {
                         function: PropertyAccess {
                          expression: Variable {
                           identifier: "pkgs",
                           position: (560, 26),
                          },
                          attribute_path: AttributePath {
                           attributes: [
                            Raw {
                             content: "writeText",
                             position: (560, 31),
                            },
                           ],
                          },
                          default: None,
                         },
                         arguments: [
                          String {
                           parts: [
                            Raw {
                             content: "graphite-beacon.json",
                             position: (560, 42),
                            },
                           ],
                          },
                          FunctionApplication {
                           function: PropertyAccess {
                            expression: Variable {
                             identifier: "builtins",
                             position: (560, 65),
                            },
                            attribute_path: AttributePath {
                             attributes: [
                              Raw {
                               content: "toJSON",
                               position: (560, 74),
                              },
                             ],
                            },
                            default: None,
                           },
                           arguments: [
                            PropertyAccess {
                             expression: Variable {
                              identifier: "cfg",
                              position: (560, 81),
                             },
                             attribute_path: AttributePath {
                              attributes: [
                               Raw {
                                content: "beacon",
                                position: (560, 85),
                               },
                               Raw {
                                content: "config",
                                position: (560, 92),
                               },
                              ],
                             },
                             default: None,
                            },
                           ],
                          },
                         ],
                        },
                       },
                       Raw {
                        content: "\n",
                        position: (560, 100),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "User",
                        position: (562, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (562, 19),
                       },
                      ],
                     },
                    ),
                    KeyValue(
                     AttributePath {
                      attributes: [
                       Raw {
                        content: "Group",
                        position: (563, 11),
                       },
                      ],
                     },
                     String {
                      parts: [
                       Raw {
                        content: "graphite",
                        position: (563, 20),
                       },
                      ],
                     },
                    ),
                   ],
                   recursive: false,
                   position: (557, 25),
                  },
                 ),
                ],
                recursive: false,
                position: (554, 42),
               },
              ),
             ],
             recursive: false,
             position: (553, 29),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "mkIf",
            position: (568, 6),
           },
           arguments: [
            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: "cfg",
                          position: (569, 7),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "carbon",
                            position: (569, 11),
                           },
                           Raw {
                            content: "enableCache",
                            position: (569, 18),
                           },
                          ],
                         },
                         default: None,
                        },
                        PropertyAccess {
                         expression: Variable {
                          identifier: "cfg",
                          position: (569, 33),
                         },
                         attribute_path: AttributePath {
                          attributes: [
                           Raw {
                            content: "carbon",
                            position: (569, 37),
                           },
                           Raw {
                            content: "enableAggregator",
                            position: (569, 44),
                           },
                          ],
                         },
                         default: None,
                        },
                       ],
                       position: (569, 30),
                      },
                      PropertyAccess {
                       expression: Variable {
                        identifier: "cfg",
                        position: (569, 64),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "carbon",
                          position: (569, 68),
                         },
                         Raw {
                          content: "enableRelay",
                          position: (569, 75),
                         },
                        ],
                       },
                       default: None,
                      },
                     ],
                     position: (569, 61),
                    },
                    PropertyAccess {
                     expression: Variable {
                      identifier: "cfg",
                      position: (570, 7),
                     },
                     attribute_path: AttributePath {
                      attributes: [
                       Raw {
                        content: "web",
                        position: (570, 11),
                       },
                       Raw {
                        content: "enable",
                        position: (570, 15),
                       },
                      ],
                     },
                     default: None,
                    },
                   ],
                   position: (569, 87),
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "cfg",
                    position: (570, 25),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "api",
                      position: (570, 29),
                     },
                     Raw {
                      content: "enable",
                      position: (570, 33),
                     },
                    ],
                   },
                   default: None,
                  },
                 ],
                 position: (570, 22),
                },
                PropertyAccess {
                 expression: Variable {
                  identifier: "cfg",
                  position: (571, 7),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "seyren",
                    position: (571, 11),
                   },
                   Raw {
                    content: "enable",
                    position: (571, 18),
                   },
                  ],
                 },
                 default: None,
                },
               ],
               position: (570, 40),
              },
              PropertyAccess {
               expression: Variable {
                identifier: "cfg",
                position: (571, 28),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "beacon",
                  position: (571, 32),
                 },
                 Raw {
                  content: "enable",
                  position: (571, 39),
                 },
                ],
               },
               default: None,
              },
             ],
             position: (571, 25),
            },
            Map {
             bindings: [
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (573, 7),
                 },
                 Raw {
                  content: "users",
                  position: (573, 13),
                 },
                 Raw {
                  content: "graphite",
                  position: (573, 19),
                 },
                ],
               },
               Map {
                bindings: [
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "uid",
                     position: (574, 9),
                    },
                   ],
                  },
                  PropertyAccess {
                   expression: Variable {
                    identifier: "config",
                    position: (574, 15),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "ids",
                      position: (574, 22),
                     },
                     Raw {
                      content: "uids",
                      position: (574, 26),
                     },
                     Raw {
                      content: "graphite",
                      position: (574, 31),
                     },
                    ],
                   },
                   default: None,
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "group",
                     position: (575, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "graphite",
                     position: (575, 18),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "description",
                     position: (576, 9),
                    },
                   ],
                  },
                  String {
                   parts: [
                    Raw {
                     content: "Graphite daemon user",
                     position: (576, 24),
                    },
                   ],
                  },
                 ),
                 KeyValue(
                  AttributePath {
                   attributes: [
                    Raw {
                     content: "home",
                     position: (577, 9),
                    },
                   ],
                  },
                  Variable {
                   identifier: "dataDir",
                   position: (577, 16),
                  },
                 ),
                ],
                recursive: false,
                position: (573, 30),
               },
              ),
              KeyValue(
               AttributePath {
                attributes: [
                 Raw {
                  content: "users",
                  position: (579, 7),
                 },
                 Raw {
                  content: "groups",
                  position: (579, 13),
                 },
                 Raw {
                  content: "graphite",
                  position: (579, 20),
                 },
                 Raw {
                  content: "gid",
                  position: (579, 29),
                 },
                ],
               },
               PropertyAccess {
                expression: Variable {
                 identifier: "config",
                 position: (579, 35),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "ids",
                   position: (579, 42),
                  },
                  Raw {
                   content: "gids",
                   position: (579, 46),
                  },
                  Raw {
                   content: "graphite",
                   position: (579, 51),
                  },
                 ],
                },
                default: None,
               },
              ),
             ],
             recursive: false,
             position: (572, 8),
            },
           ],
          },
         ],
         position: (371, 20),
        },
       ],
      },
     ),
    ],
    recursive: false,
    position: (72, 4),
   },
   position: (5, 1),
  },
  position: (3, 1),
 },
 position: (1, 1),
}