---
Function {
 argument: None,
 arguments: FunctionArguments {
  arguments: [
   FunctionArgument {
    identifier: "lib",
    default: None,
   },
  ],
  ellipsis: false,
 },
 definition: LetIn {
  bindings: [
   Inherit(
    Some(
     Variable {
      identifier: "builtins",
      position: (5, 10),
     },
    ),
    [
     Raw {
      content: "length",
      position: (5, 20),
     },
    ],
   ),
  ],
  target: Map {
   bindings: [
    Inherit(
     Some(
      Variable {
       identifier: "builtins",
       position: (11, 12),
      },
     ),
     [
      Raw {
       content: "compareVersions",
       position: (12, 5),
      },
      Raw {
       content: "elem",
       position: (13, 5),
      },
      Raw {
       content: "elemAt",
       position: (14, 5),
      },
      Raw {
       content: "filter",
       position: (15, 5),
      },
      Raw {
       content: "fromJSON",
       position: (16, 5),
      },
      Raw {
       content: "head",
       position: (17, 5),
      },
      Raw {
       content: "isInt",
       position: (18, 5),
      },
      Raw {
       content: "isList",
       position: (19, 5),
      },
      Raw {
       content: "isString",
       position: (20, 5),
      },
      Raw {
       content: "match",
       position: (21, 5),
      },
      Raw {
       content: "parseDrvName",
       position: (22, 5),
      },
      Raw {
       content: "readFile",
       position: (23, 5),
      },
      Raw {
       content: "replaceStrings",
       position: (24, 5),
      },
      Raw {
       content: "split",
       position: (25, 5),
      },
      Raw {
       content: "storeDir",
       position: (26, 5),
      },
      Raw {
       content: "stringLength",
       position: (27, 5),
      },
      Raw {
       content: "substring",
       position: (28, 5),
      },
      Raw {
       content: "tail",
       position: (29, 5),
      },
      Raw {
       content: "toJSON",
       position: (30, 5),
      },
      Raw {
       content: "typeOf",
       position: (31, 5),
      },
      Raw {
       content: "unsafeDiscardStringContext",
       position: (32, 5),
      },
     ],
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "concatStrings",
        position: (43, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (43, 19),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "concatStringsSep",
          position: (43, 28),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "concatMapStrings",
        position: (53, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "f",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "list",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStrings",
         position: (53, 31),
        },
        arguments: [
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (53, 46),
          },
          arguments: [
           Variable {
            identifier: "f",
            position: (53, 50),
           },
           Variable {
            identifier: "list",
            position: (53, 52),
           },
          ],
         },
        ],
       },
       position: (53, 25),
      },
      position: (53, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "concatImapStrings",
        position: (64, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "f",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "list",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStrings",
         position: (64, 32),
        },
        arguments: [
         FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (64, 47),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "imap1",
              position: (64, 51),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Variable {
            identifier: "f",
            position: (64, 57),
           },
           Variable {
            identifier: "list",
            position: (64, 59),
           },
          ],
         },
        ],
       },
       position: (64, 26),
      },
      position: (64, 23),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "intersperse",
        position: (74, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "separator",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "list",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: IfThenElse {
        predicate: BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            Variable {
             identifier: "list",
             position: (79, 8),
            },
            List {
             elements: [],
             position: (79, 16),
            },
           ],
           position: (79, 13),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "length",
              position: (79, 22),
             },
             arguments: [
              Variable {
               identifier: "list",
               position: (79, 29),
              },
             ],
            },
            Int {
             value: 1,
             position: (79, 37),
            },
           ],
           position: (79, 34),
          },
         ],
         position: (79, 19),
        },
        then: Variable {
         identifier: "list",
         position: (80, 10),
        },
        else_: FunctionApplication {
         function: Variable {
          identifier: "tail",
          position: (81, 10),
         },
         arguments: [
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (81, 16),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "concatMap",
               position: (81, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Function {
             argument: Some(
              "x",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: List {
              elements: [
               Variable {
                identifier: "separator",
                position: (81, 35),
               },
               Variable {
                identifier: "x",
                position: (81, 45),
               },
              ],
              position: (81, 34),
             },
             position: (81, 31),
            },
            Variable {
             identifier: "list",
             position: (81, 49),
            },
           ],
          },
         ],
        },
        position: (79, 5),
       },
       position: (78, 5),
      },
      position: (76, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "concatStringsSep",
        position: (91, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (91, 22),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "concatStringsSep",
         position: (91, 31),
        },
       ],
      },
      default: Some(
       Function {
        argument: Some(
         "separator",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "list",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: FunctionApplication {
          function: PropertyAccess {
           expression: Variable {
            identifier: "lib",
            position: (92, 5),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "foldl'",
              position: (92, 9),
             },
            ],
           },
           default: None,
          },
          arguments: [
           Function {
            argument: Some(
             "x",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: Function {
             argument: Some(
              "y",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: BinaryOperation {
              operator: Addition,
              operands: [
               Variable {
                identifier: "x",
                position: (92, 23),
               },
               Variable {
                identifier: "y",
                position: (92, 27),
               },
              ],
              position: (92, 25),
             },
             position: (92, 20),
            },
            position: (92, 17),
           },
           String {
            parts: [],
           },
           FunctionApplication {
            function: Variable {
             identifier: "intersperse",
             position: (92, 34),
            },
            arguments: [
             Variable {
              identifier: "separator",
              position: (92, 46),
             },
             Variable {
              identifier: "list",
              position: (92, 56),
             },
            ],
           },
          ],
         },
         position: (91, 63),
        },
        position: (91, 52),
       },
      ),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "concatMapStringsSep",
        position: (104, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "sep",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "f",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "list",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (110, 11),
         },
         arguments: [
          Variable {
           identifier: "sep",
           position: (110, 28),
          },
          FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (110, 33),
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (110, 37),
            },
            Variable {
             identifier: "list",
             position: (110, 39),
            },
           ],
          },
         ],
        },
        position: (110, 5),
       },
       position: (108, 5),
      },
      position: (106, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "concatImapStringsSep",
        position: (121, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "sep",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "f",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "list",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "concatStringsSep",
          position: (127, 11),
         },
         arguments: [
          Variable {
           identifier: "sep",
           position: (127, 28),
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (127, 33),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "imap1",
               position: (127, 37),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "f",
             position: (127, 43),
            },
            Variable {
             identifier: "list",
             position: (127, 45),
            },
           ],
          },
         ],
        },
        position: (127, 5),
       },
       position: (125, 5),
      },
      position: (123, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeSearchPath",
        position: (140, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "subDir",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "paths",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStringsSep",
         position: (145, 5),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: ":",
            position: (145, 23),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (145, 27),
          },
          arguments: [
           Function {
            argument: Some(
             "path",
            ),
            arguments: FunctionArguments {
             arguments: [],
             ellipsis: false,
            },
            definition: BinaryOperation {
             operator: Addition,
             operands: [
              BinaryOperation {
               operator: Addition,
               operands: [
                Variable {
                 identifier: "path",
                 position: (145, 38),
                },
                String {
                 parts: [
                  Raw {
                   content: "/",
                   position: (145, 46),
                  },
                 ],
                },
               ],
               position: (145, 43),
              },
              Variable {
               identifier: "subDir",
               position: (145, 51),
              },
             ],
             position: (145, 49),
            },
            position: (145, 32),
           },
           FunctionApplication {
            function: Variable {
             identifier: "filter",
             position: (145, 60),
            },
            arguments: [
             Function {
              argument: Some(
               "x",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: BinaryOperation {
               operator: NotEqualTo,
               operands: [
                Variable {
                 identifier: "x",
                 position: (145, 71),
                },
                Variable {
                 identifier: "null",
                 position: (145, 76),
                },
               ],
               position: (145, 73),
              },
              position: (145, 68),
             },
             Variable {
              identifier: "paths",
              position: (145, 82),
             },
            ],
           },
          ],
         },
        ],
       },
       position: (144, 5),
      },
      position: (142, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeSearchPathOutput",
        position: (158, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "output",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "subDir",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "pkgs",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: FunctionApplication {
         function: Variable {
          identifier: "makeSearchPath",
          position: (164, 11),
         },
         arguments: [
          Variable {
           identifier: "subDir",
           position: (164, 26),
          },
          FunctionApplication {
           function: Variable {
            identifier: "map",
            position: (164, 34),
           },
           arguments: [
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (164, 39),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "getOutput",
                 position: (164, 43),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Variable {
               identifier: "output",
               position: (164, 53),
              },
             ],
            },
            Variable {
             identifier: "pkgs",
             position: (164, 61),
            },
           ],
          },
         ],
        },
        position: (164, 5),
       },
       position: (162, 5),
      },
      position: (160, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeLibraryPath",
        position: (176, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "makeSearchPathOutput",
       position: (176, 21),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "lib",
          position: (176, 43),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "lib",
          position: (176, 49),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "makeBinPath",
        position: (185, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "makeSearchPathOutput",
       position: (185, 17),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "bin",
          position: (185, 39),
         },
        ],
       },
       String {
        parts: [
         Raw {
          content: "bin",
          position: (185, 45),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "optionalString",
        position: (198, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "cond",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "string",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: IfThenElse {
        predicate: Variable {
         identifier: "cond",
         position: (202, 16),
        },
        then: Variable {
         identifier: "string",
         position: (202, 26),
        },
        else_: String {
         parts: [],
        },
        position: (202, 13),
       },
       position: (202, 5),
      },
      position: (200, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "hasPrefix",
        position: (214, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "pref",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "str",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: BinaryOperation {
        operator: EqualTo,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (218, 10),
          },
          arguments: [
           Int {
            value: 0,
            position: (218, 20),
           },
           FunctionApplication {
            function: Variable {
             identifier: "stringLength",
             position: (218, 23),
            },
            arguments: [
             Variable {
              identifier: "pref",
              position: (218, 36),
             },
            ],
           },
           Variable {
            identifier: "str",
            position: (218, 42),
           },
          ],
         },
         Variable {
          identifier: "pref",
          position: (218, 49),
         },
        ],
        position: (218, 46),
       },
       position: (218, 5),
      },
      position: (216, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "hasSuffix",
        position: (230, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "suffix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "lenContent",
             position: (236, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (236, 20),
           },
           arguments: [
            Variable {
             identifier: "content",
             position: (236, 33),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "lenSuffix",
             position: (237, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (237, 19),
           },
           arguments: [
            Variable {
             identifier: "suffix",
             position: (237, 32),
            },
           ],
          },
         ),
        ],
        target: BinaryOperation {
         operator: LogicalAnd,
         operands: [
          BinaryOperation {
           operator: GreaterThanOrEqualTo,
           operands: [
            Variable {
             identifier: "lenContent",
             position: (238, 8),
            },
            Variable {
             identifier: "lenSuffix",
             position: (238, 22),
            },
           ],
           position: (238, 19),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "substring",
              position: (239, 8),
             },
             arguments: [
              BinaryOperation {
               operator: Subtraction,
               operands: [
                Variable {
                 identifier: "lenContent",
                 position: (239, 19),
                },
                Variable {
                 identifier: "lenSuffix",
                 position: (239, 32),
                },
               ],
               position: (239, 30),
              },
              Variable {
               identifier: "lenContent",
               position: (239, 43),
              },
              Variable {
               identifier: "content",
               position: (239, 54),
              },
             ],
            },
            Variable {
             identifier: "suffix",
             position: (239, 65),
            },
           ],
           position: (239, 62),
          },
         ],
         position: (238, 32),
        },
        position: (235, 5),
       },
       position: (234, 5),
      },
      position: (232, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "hasInfix",
        position: (255, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "infix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "content",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "drop",
             position: (257, 7),
            },
           ],
          },
          Function {
           argument: Some(
            "x",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "substring",
             position: (257, 17),
            },
            arguments: [
             Int {
              value: 1,
              position: (257, 27),
             },
             FunctionApplication {
              function: Variable {
               identifier: "stringLength",
               position: (257, 30),
              },
              arguments: [
               Variable {
                identifier: "x",
                position: (257, 43),
               },
              ],
             },
             Variable {
              identifier: "x",
              position: (257, 46),
             },
            ],
           },
           position: (257, 14),
          },
         ),
        ],
        target: BinaryOperation {
         operator: LogicalOr,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "hasPrefix",
            position: (258, 8),
           },
           arguments: [
            Variable {
             identifier: "infix",
             position: (258, 18),
            },
            Variable {
             identifier: "content",
             position: (258, 24),
            },
           ],
          },
          BinaryOperation {
           operator: LogicalAnd,
           operands: [
            BinaryOperation {
             operator: NotEqualTo,
             operands: [
              Variable {
               identifier: "content",
               position: (259, 10),
              },
              String {
               parts: [],
              },
             ],
             position: (259, 18),
            },
            FunctionApplication {
             function: Variable {
              identifier: "hasInfix",
              position: (259, 27),
             },
             arguments: [
              Variable {
               identifier: "infix",
               position: (259, 36),
              },
              FunctionApplication {
               function: Variable {
                identifier: "drop",
                position: (259, 43),
               },
               arguments: [
                Variable {
                 identifier: "content",
                 position: (259, 48),
                },
               ],
              },
             ],
            },
           ],
           position: (259, 24),
          },
         ],
         position: (259, 7),
        },
        position: (256, 5),
       },
       position: (255, 21),
      },
      position: (255, 14),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "stringToCharacters",
        position: (279, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "s",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "map",
        position: (280, 5),
       },
       arguments: [
        Function {
         argument: Some(
          "p",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (280, 13),
          },
          arguments: [
           Variable {
            identifier: "p",
            position: (280, 23),
           },
           Int {
            value: 1,
            position: (280, 25),
           },
           Variable {
            identifier: "s",
            position: (280, 27),
           },
          ],
         },
         position: (280, 10),
        },
        FunctionApplication {
         function: PropertyAccess {
          expression: Variable {
           identifier: "lib",
           position: (280, 31),
          },
          attribute_path: AttributePath {
           attributes: [
            Raw {
             content: "range",
             position: (280, 35),
            },
           ],
          },
          default: None,
         },
         arguments: [
          Int {
           value: 0,
           position: (280, 41),
          },
          BinaryOperation {
           operator: Subtraction,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "stringLength",
              position: (280, 44),
             },
             arguments: [
              Variable {
               identifier: "s",
               position: (280, 57),
              },
             ],
            },
            Int {
             value: 1,
             position: (280, 61),
            },
           ],
           position: (280, 59),
          },
         ],
        },
       ],
      },
      position: (279, 24),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "stringAsChars",
        position: (291, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "f",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "s",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "concatStrings",
         position: (295, 8),
        },
        arguments: [
         FunctionApplication {
          function: Variable {
           identifier: "map",
           position: (296, 7),
          },
          arguments: [
           Variable {
            identifier: "f",
            position: (296, 11),
           },
           FunctionApplication {
            function: Variable {
             identifier: "stringToCharacters",
             position: (296, 14),
            },
            arguments: [
             Variable {
              identifier: "s",
              position: (296, 33),
             },
            ],
           },
          ],
         },
        ],
       },
       position: (295, 5),
      },
      position: (293, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escape",
        position: (308, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "list",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "replaceChars",
        position: (308, 18),
       },
       arguments: [
        Variable {
         identifier: "list",
         position: (308, 31),
        },
        FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (308, 37),
         },
         arguments: [
          Function {
           argument: Some(
            "c",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: String {
            parts: [
             Raw {
              content: "\\",
              position: (308, 46),
             },
             Expression {
              expression: Variable {
               identifier: "c",
               position: (308, 50),
              },
             },
            ],
           },
           position: (308, 42),
          },
          Variable {
           identifier: "list",
           position: (308, 55),
          },
         ],
        },
       ],
      },
      position: (308, 12),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escapeShellArg",
        position: (318, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "arg",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: String {
       parts: [
        Raw {
         content: "'",
         position: (318, 26),
        },
        Expression {
         expression: FunctionApplication {
          function: Variable {
           identifier: "replaceStrings",
           position: (318, 29),
          },
          arguments: [
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "'",
                position: (318, 46),
               },
              ],
             },
            ],
            position: (318, 44),
           },
           List {
            elements: [
             String {
              parts: [
               Raw {
                content: "'\\''",
                position: (318, 52),
               },
              ],
             },
            ],
            position: (318, 50),
           },
           FunctionApplication {
            function: Variable {
             identifier: "toString",
             position: (318, 61),
            },
            arguments: [
             Variable {
              identifier: "arg",
              position: (318, 70),
             },
            ],
           },
          ],
         },
        },
        Raw {
         content: "'",
         position: (318, 75),
        },
       ],
      },
      position: (318, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escapeShellArgs",
        position: (328, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "concatMapStringsSep",
       position: (328, 21),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: " ",
          position: (328, 42),
         },
        ],
       },
       Variable {
        identifier: "escapeShellArg",
        position: (328, 45),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escapeNixString",
        position: (338, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "s",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "escape",
        position: (338, 24),
       },
       arguments: [
        List {
         elements: [
          String {
           parts: [
            Raw {
             content: "$",
             position: (338, 33),
            },
           ],
          },
         ],
         position: (338, 31),
        },
        FunctionApplication {
         function: Variable {
          identifier: "toJSON",
          position: (338, 38),
         },
         arguments: [
          Variable {
           identifier: "s",
           position: (338, 45),
          },
         ],
        },
       ],
      },
      position: (338, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escapeRegex",
        position: (348, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "escape",
       position: (348, 17),
      },
      arguments: [
       FunctionApplication {
        function: Variable {
         identifier: "stringToCharacters",
         position: (348, 25),
        },
        arguments: [
         String {
          parts: [
           Raw {
            content: "\\[{()^$?*+|.",
            position: (348, 45),
           },
          ],
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escapeNixIdentifier",
        position: (360, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "s",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: NotEqualTo,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "match",
           position: (362, 8),
          },
          arguments: [
           String {
            parts: [
             Raw {
              content: "[a-zA-Z_][a-zA-Z0-9_'-]*",
              position: (362, 15),
             },
            ],
           },
           Variable {
            identifier: "s",
            position: (362, 41),
           },
          ],
         },
         Variable {
          identifier: "null",
          position: (362, 46),
         },
        ],
        position: (362, 43),
       },
       then: Variable {
        identifier: "s",
        position: (363, 10),
       },
       else_: FunctionApplication {
        function: Variable {
         identifier: "escapeNixString",
         position: (363, 17),
        },
        arguments: [
         Variable {
          identifier: "s",
          position: (363, 33),
         },
        ],
       },
       position: (362, 5),
      },
      position: (360, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "escapeXML",
        position: (374, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "builtins",
        position: (374, 15),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "replaceStrings",
          position: (374, 24),
         },
        ],
       },
       default: None,
      },
      arguments: [
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "\"",
            position: (375, 7),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "'",
            position: (375, 12),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "<",
            position: (375, 16),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: ">",
            position: (375, 20),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "&",
            position: (375, 24),
           },
          ],
         },
        ],
        position: (375, 5),
       },
       List {
        elements: [
         String {
          parts: [
           Raw {
            content: "&quot;",
            position: (376, 7),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "&apos;",
            position: (376, 16),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "&lt;",
            position: (376, 25),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "&gt;",
            position: (376, 32),
           },
          ],
         },
         String {
          parts: [
           Raw {
            content: "&amp;",
            position: (376, 39),
           },
          ],
         },
        ],
        position: (376, 5),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "replaceChars",
        position: (379, 3),
       },
      ],
     },
     PropertyAccess {
      expression: Variable {
       identifier: "builtins",
       position: (379, 18),
      },
      attribute_path: AttributePath {
       attributes: [
        Raw {
         content: "replaceStrings",
         position: (379, 27),
        },
       ],
      },
      default: Some(
       Function {
        argument: Some(
         "del",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "new",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: Function {
          argument: Some(
           "s",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: LetIn {
           bindings: [
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "substList",
                position: (382, 7),
               },
              ],
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (382, 19),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "zipLists",
                  position: (382, 23),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "del",
                position: (382, 32),
               },
               Variable {
                identifier: "new",
                position: (382, 36),
               },
              ],
             },
            ),
            KeyValue(
             AttributePath {
              attributes: [
               Raw {
                content: "subst",
                position: (383, 7),
               },
              ],
             },
             Function {
              argument: Some(
               "c",
              ),
              arguments: FunctionArguments {
               arguments: [],
               ellipsis: false,
              },
              definition: LetIn {
               bindings: [
                KeyValue(
                 AttributePath {
                  attributes: [
                   Raw {
                    content: "found",
                    position: (384, 13),
                   },
                  ],
                 },
                 FunctionApplication {
                  function: PropertyAccess {
                   expression: Variable {
                    identifier: "lib",
                    position: (384, 21),
                   },
                   attribute_path: AttributePath {
                    attributes: [
                     Raw {
                      content: "findFirst",
                      position: (384, 25),
                     },
                    ],
                   },
                   default: None,
                  },
                  arguments: [
                   Function {
                    argument: Some(
                     "sub",
                    ),
                    arguments: FunctionArguments {
                     arguments: [],
                     ellipsis: false,
                    },
                    definition: BinaryOperation {
                     operator: EqualTo,
                     operands: [
                      PropertyAccess {
                       expression: Variable {
                        identifier: "sub",
                        position: (384, 41),
                       },
                       attribute_path: AttributePath {
                        attributes: [
                         Raw {
                          content: "fst",
                          position: (384, 45),
                         },
                        ],
                       },
                       default: None,
                      },
                      Variable {
                       identifier: "c",
                       position: (384, 52),
                      },
                     ],
                     position: (384, 49),
                    },
                    position: (384, 36),
                   },
                   Variable {
                    identifier: "null",
                    position: (384, 55),
                   },
                   Variable {
                    identifier: "substList",
                    position: (384, 60),
                   },
                  ],
                 },
                ),
               ],
               target: IfThenElse {
                predicate: BinaryOperation {
                 operator: EqualTo,
                 operands: [
                  Variable {
                   identifier: "found",
                   position: (385, 12),
                  },
                  Variable {
                   identifier: "null",
                   position: (385, 21),
                  },
                 ],
                 position: (385, 18),
                },
                then: Variable {
                 identifier: "c",
                 position: (386, 11),
                },
                else_: PropertyAccess {
                 expression: Variable {
                  identifier: "found",
                  position: (388, 11),
                 },
                 attribute_path: AttributePath {
                  attributes: [
                   Raw {
                    content: "snd",
                    position: (388, 17),
                   },
                  ],
                 },
                 default: None,
                },
                position: (385, 9),
               },
               position: (384, 9),
              },
              position: (383, 15),
             },
            ),
           ],
           target: FunctionApplication {
            function: Variable {
             identifier: "stringAsChars",
             position: (390, 7),
            },
            arguments: [
             Variable {
              identifier: "subst",
              position: (390, 21),
             },
             Variable {
              identifier: "s",
              position: (390, 27),
             },
            ],
           },
           position: (381, 5),
          },
          position: (380, 15),
         },
         position: (380, 10),
        },
        position: (380, 5),
       },
      ),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "lowerChars",
        position: (393, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "stringToCharacters",
       position: (393, 16),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "abcdefghijklmnopqrstuvwxyz",
          position: (393, 36),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "upperChars",
        position: (394, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "stringToCharacters",
       position: (394, 16),
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
          position: (394, 36),
         },
        ],
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "toLower",
        position: (404, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "replaceChars",
       position: (404, 13),
      },
      arguments: [
       Variable {
        identifier: "upperChars",
        position: (404, 26),
       },
       Variable {
        identifier: "lowerChars",
        position: (404, 37),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "toUpper",
        position: (414, 3),
       },
      ],
     },
     FunctionApplication {
      function: Variable {
       identifier: "replaceChars",
       position: (414, 13),
      },
      arguments: [
       Variable {
        identifier: "lowerChars",
        position: (414, 26),
       },
       Variable {
        identifier: "upperChars",
        position: (414, 37),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "addContextFrom",
        position: (429, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "a",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "b",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: BinaryOperation {
        operator: Addition,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (429, 26),
          },
          arguments: [
           Int {
            value: 0,
            position: (429, 36),
           },
           Int {
            value: 0,
            position: (429, 38),
           },
           Variable {
            identifier: "a",
            position: (429, 40),
           },
          ],
         },
         Variable {
          identifier: "b",
          position: (429, 44),
         },
        ],
        position: (429, 42),
       },
       position: (429, 23),
      },
      position: (429, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "splitString",
        position: (440, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "_sep",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "_s",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sep",
             position: (442, 7),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (442, 13),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "unsafeDiscardStringContext",
               position: (442, 22),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "_sep",
             position: (442, 49),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "s",
             position: (443, 7),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (443, 11),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "unsafeDiscardStringContext",
               position: (443, 20),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "_s",
             position: (443, 47),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "splits",
             position: (444, 7),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "builtins",
             position: (444, 16),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "filter",
               position: (444, 25),
              },
             ],
            },
            default: None,
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "builtins",
              position: (444, 32),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "isString",
                position: (444, 41),
               },
              ],
             },
             default: None,
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "builtins",
               position: (444, 51),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "split",
                 position: (444, 60),
                },
               ],
              },
              default: None,
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "escapeRegex",
                position: (444, 67),
               },
               arguments: [
                Variable {
                 identifier: "sep",
                 position: (444, 79),
                },
               ],
              },
              Variable {
               identifier: "s",
               position: (444, 84),
              },
             ],
            },
           ],
          },
         ),
        ],
        target: FunctionApplication {
         function: Variable {
          identifier: "map",
          position: (446, 7),
         },
         arguments: [
          Function {
           argument: Some(
            "v",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "addContextFrom",
             position: (446, 15),
            },
            arguments: [
             Variable {
              identifier: "_sep",
              position: (446, 30),
             },
             FunctionApplication {
              function: Variable {
               identifier: "addContextFrom",
               position: (446, 36),
              },
              arguments: [
               Variable {
                identifier: "_s",
                position: (446, 51),
               },
               Variable {
                identifier: "v",
                position: (446, 54),
               },
              ],
             },
            ],
           },
           position: (446, 12),
          },
          Variable {
           identifier: "splits",
           position: (446, 58),
          },
         ],
        },
        position: (441, 5),
       },
       position: (440, 23),
      },
      position: (440, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "removePrefix",
        position: (458, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "prefix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "str",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "preLen",
             position: (464, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (464, 16),
           },
           arguments: [
            Variable {
             identifier: "prefix",
             position: (464, 29),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sLen",
             position: (465, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (465, 14),
           },
           arguments: [
            Variable {
             identifier: "str",
             position: (465, 27),
            },
           ],
          },
         ),
        ],
        target: IfThenElse {
         predicate: FunctionApplication {
          function: Variable {
           identifier: "hasPrefix",
           position: (467, 10),
          },
          arguments: [
           Variable {
            identifier: "prefix",
            position: (467, 20),
           },
           Variable {
            identifier: "str",
            position: (467, 27),
           },
          ],
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (468, 9),
          },
          arguments: [
           Variable {
            identifier: "preLen",
            position: (468, 19),
           },
           BinaryOperation {
            operator: Subtraction,
            operands: [
             Variable {
              identifier: "sLen",
              position: (468, 27),
             },
             Variable {
              identifier: "preLen",
              position: (468, 34),
             },
            ],
            position: (468, 32),
           },
           Variable {
            identifier: "str",
            position: (468, 42),
           },
          ],
         },
         else_: Variable {
          identifier: "str",
          position: (470, 9),
         },
         position: (467, 7),
        },
        position: (463, 5),
       },
       position: (462, 5),
      },
      position: (460, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "removeSuffix",
        position: (482, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "suffix",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "str",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sufLen",
             position: (488, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (488, 16),
           },
           arguments: [
            Variable {
             identifier: "suffix",
             position: (488, 29),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "sLen",
             position: (489, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "stringLength",
            position: (489, 14),
           },
           arguments: [
            Variable {
             identifier: "str",
             position: (489, 27),
            },
           ],
          },
         ),
        ],
        target: IfThenElse {
         predicate: BinaryOperation {
          operator: LogicalAnd,
          operands: [
           BinaryOperation {
            operator: LessThanOrEqualTo,
            operands: [
             Variable {
              identifier: "sufLen",
              position: (491, 10),
             },
             Variable {
              identifier: "sLen",
              position: (491, 20),
             },
            ],
            position: (491, 17),
           },
           BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "suffix",
              position: (491, 28),
             },
             FunctionApplication {
              function: Variable {
               identifier: "substring",
               position: (491, 38),
              },
              arguments: [
               BinaryOperation {
                operator: Subtraction,
                operands: [
                 Variable {
                  identifier: "sLen",
                  position: (491, 49),
                 },
                 Variable {
                  identifier: "sufLen",
                  position: (491, 56),
                 },
                ],
                position: (491, 54),
               },
               Variable {
                identifier: "sufLen",
                position: (491, 64),
               },
               Variable {
                identifier: "str",
                position: (491, 71),
               },
              ],
             },
            ],
            position: (491, 35),
           },
          ],
          position: (491, 25),
         },
         then: FunctionApplication {
          function: Variable {
           identifier: "substring",
           position: (492, 9),
          },
          arguments: [
           Int {
            value: 0,
            position: (492, 19),
           },
           BinaryOperation {
            operator: Subtraction,
            operands: [
             Variable {
              identifier: "sLen",
              position: (492, 22),
             },
             Variable {
              identifier: "sufLen",
              position: (492, 29),
             },
            ],
            position: (492, 27),
           },
           Variable {
            identifier: "str",
            position: (492, 37),
           },
          ],
         },
         else_: Variable {
          identifier: "str",
          position: (494, 9),
         },
         position: (491, 7),
        },
        position: (487, 5),
       },
       position: (486, 5),
      },
      position: (484, 5),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "versionOlder",
        position: (504, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "v1",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "v2",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: BinaryOperation {
        operator: EqualTo,
        operands: [
         FunctionApplication {
          function: Variable {
           identifier: "compareVersions",
           position: (504, 26),
          },
          arguments: [
           Variable {
            identifier: "v2",
            position: (504, 42),
           },
           Variable {
            identifier: "v1",
            position: (504, 45),
           },
          ],
         },
         Int {
          value: 1,
          position: (504, 51),
         },
        ],
        position: (504, 48),
       },
       position: (504, 22),
      },
      position: (504, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "versionAtLeast",
        position: (516, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "v1",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "v2",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: UnaryOperation {
        operator: Not,
        operand: FunctionApplication {
         function: Variable {
          identifier: "versionOlder",
          position: (516, 29),
         },
         arguments: [
          Variable {
           identifier: "v1",
           position: (516, 42),
          },
          Variable {
           identifier: "v2",
           position: (516, 45),
          },
         ],
        },
        position: (516, 28),
       },
       position: (516, 24),
      },
      position: (516, 20),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "getName",
        position: (528, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "parse",
            position: (530, 6),
           },
          ],
         },
         Function {
          argument: Some(
           "drv",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: PropertyAccess {
           expression: FunctionApplication {
            function: Variable {
             identifier: "parseDrvName",
             position: (530, 20),
            },
            arguments: [
             Variable {
              identifier: "drv",
              position: (530, 33),
             },
            ],
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "name",
              position: (530, 38),
             },
            ],
           },
           default: None,
          },
          position: (530, 14),
         },
        ),
       ],
       target: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (531, 10),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (531, 19),
          },
         ],
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "parse",
          position: (532, 12),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (532, 18),
          },
         ],
        },
        else_: PropertyAccess {
         expression: Variable {
          identifier: "x",
          position: (533, 12),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "pname",
            position: (533, 14),
           },
          ],
         },
         default: Some(
          FunctionApplication {
           function: Variable {
            identifier: "parse",
            position: (533, 24),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "x",
              position: (533, 30),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (533, 32),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        },
        position: (531, 7),
       },
       position: (529, 4),
      },
      position: (528, 13),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "getVersion",
        position: (545, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "parse",
            position: (547, 6),
           },
          ],
         },
         Function {
          argument: Some(
           "drv",
          ),
          arguments: FunctionArguments {
           arguments: [],
           ellipsis: false,
          },
          definition: PropertyAccess {
           expression: FunctionApplication {
            function: Variable {
             identifier: "parseDrvName",
             position: (547, 20),
            },
            arguments: [
             Variable {
              identifier: "drv",
              position: (547, 33),
             },
            ],
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "version",
              position: (547, 38),
             },
            ],
           },
           default: None,
          },
          position: (547, 14),
         },
        ),
       ],
       target: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (548, 10),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (548, 19),
          },
         ],
        },
        then: FunctionApplication {
         function: Variable {
          identifier: "parse",
          position: (549, 12),
         },
         arguments: [
          Variable {
           identifier: "x",
           position: (549, 18),
          },
         ],
        },
        else_: PropertyAccess {
         expression: Variable {
          identifier: "x",
          position: (550, 12),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "version",
            position: (550, 14),
           },
          ],
         },
         default: Some(
          FunctionApplication {
           function: Variable {
            identifier: "parse",
            position: (550, 26),
           },
           arguments: [
            PropertyAccess {
             expression: Variable {
              identifier: "x",
              position: (550, 32),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "name",
                position: (550, 34),
               },
              ],
             },
             default: None,
            },
           ],
          },
         ),
        },
        position: (548, 7),
       },
       position: (546, 4),
      },
      position: (545, 16),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "nameFromURL",
        position: (561, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "url",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "sep",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "components",
             position: (563, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "splitString",
            position: (563, 20),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "/",
               position: (563, 33),
              },
             ],
            },
            Variable {
             identifier: "url",
             position: (563, 36),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "filename",
             position: (564, 7),
            },
           ],
          },
          FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (564, 18),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "last",
               position: (564, 22),
              },
             ],
            },
            default: None,
           },
           arguments: [
            Variable {
             identifier: "components",
             position: (564, 27),
            },
           ],
          },
         ),
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "name",
             position: (565, 7),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "head",
            position: (565, 14),
           },
           arguments: [
            FunctionApplication {
             function: Variable {
              identifier: "splitString",
              position: (565, 20),
             },
             arguments: [
              Variable {
               identifier: "sep",
               position: (565, 32),
              },
              Variable {
               identifier: "filename",
               position: (565, 36),
              },
             ],
            },
           ],
          },
         ),
        ],
        target: Assert {
         expression: BinaryOperation {
          operator: NotEqualTo,
          operands: [
           Variable {
            identifier: "name",
            position: (566, 15),
           },
           Variable {
            identifier: "filename",
            position: (566, 23),
           },
          ],
          position: (566, 20),
         },
         target: Variable {
          identifier: "name",
          position: (566, 33),
         },
         position: (566, 8),
        },
        position: (562, 5),
       },
       position: (561, 22),
      },
      position: (561, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "enableFeature",
        position: (577, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "enable",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "feat",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Assert {
        expression: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (578, 12),
         },
         arguments: [
          Variable {
           identifier: "feat",
           position: (578, 21),
          },
         ],
        },
        target: String {
         parts: [
          Raw {
           content: "--",
           position: (579, 6),
          },
          Expression {
           expression: IfThenElse {
            predicate: Variable {
             identifier: "enable",
             position: (579, 13),
            },
            then: String {
             parts: [
              Raw {
               content: "enable",
               position: (579, 26),
              },
             ],
            },
            else_: String {
             parts: [
              Raw {
               content: "disable",
               position: (579, 40),
              },
             ],
            },
            position: (579, 10),
           },
          },
          Raw {
           content: "-",
           position: (579, 49),
          },
          Expression {
           expression: Variable {
            identifier: "feat",
            position: (579, 52),
           },
          },
         ],
        },
        position: (578, 5),
       },
       position: (577, 27),
      },
      position: (577, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "enableFeatureAs",
        position: (590, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "enable",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "feat",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "value",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: BinaryOperation {
         operator: Addition,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "enableFeature",
            position: (590, 42),
           },
           arguments: [
            Variable {
             identifier: "enable",
             position: (590, 56),
            },
            Variable {
             identifier: "feat",
             position: (590, 63),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (590, 70),
           },
           arguments: [
            Variable {
             identifier: "enable",
             position: (590, 85),
            },
            String {
             parts: [
              Raw {
               content: "=",
               position: (590, 93),
              },
              Expression {
               expression: Variable {
                identifier: "value",
                position: (590, 96),
               },
              },
             ],
            },
           ],
          },
         ],
         position: (590, 68),
        },
        position: (590, 35),
       },
       position: (590, 29),
      },
      position: (590, 21),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "withFeature",
        position: (601, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "with_",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "feat",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Assert {
        expression: FunctionApplication {
         function: Variable {
          identifier: "isString",
          position: (602, 12),
         },
         arguments: [
          Variable {
           identifier: "feat",
           position: (602, 21),
          },
         ],
        },
        target: String {
         parts: [
          Raw {
           content: "--",
           position: (603, 6),
          },
          Expression {
           expression: IfThenElse {
            predicate: Variable {
             identifier: "with_",
             position: (603, 13),
            },
            then: String {
             parts: [
              Raw {
               content: "with",
               position: (603, 25),
              },
             ],
            },
            else_: String {
             parts: [
              Raw {
               content: "without",
               position: (603, 37),
              },
             ],
            },
            position: (603, 10),
           },
          },
          Raw {
           content: "-",
           position: (603, 46),
          },
          Expression {
           expression: Variable {
            identifier: "feat",
            position: (603, 49),
           },
          },
         ],
        },
        position: (602, 5),
       },
       position: (601, 24),
      },
      position: (601, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "withFeatureAs",
        position: (614, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "with_",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "feat",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "value",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: BinaryOperation {
         operator: Addition,
         operands: [
          FunctionApplication {
           function: Variable {
            identifier: "withFeature",
            position: (614, 39),
           },
           arguments: [
            Variable {
             identifier: "with_",
             position: (614, 51),
            },
            Variable {
             identifier: "feat",
             position: (614, 57),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "optionalString",
            position: (614, 64),
           },
           arguments: [
            Variable {
             identifier: "with_",
             position: (614, 79),
            },
            String {
             parts: [
              Raw {
               content: "=",
               position: (614, 86),
              },
              Expression {
               expression: Variable {
                identifier: "value",
                position: (614, 89),
               },
              },
             ],
            },
           ],
          },
         ],
         position: (614, 62),
        },
        position: (614, 32),
       },
       position: (614, 26),
      },
      position: (614, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fixedWidthString",
        position: (628, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "width",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "filler",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: Function {
        argument: Some(
         "str",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: LetIn {
         bindings: [
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "strw",
              position: (630, 7),
             },
            ],
           },
           FunctionApplication {
            function: PropertyAccess {
             expression: Variable {
              identifier: "lib",
              position: (630, 14),
             },
             attribute_path: AttributePath {
              attributes: [
               Raw {
                content: "stringLength",
                position: (630, 18),
               },
              ],
             },
             default: None,
            },
            arguments: [
             Variable {
              identifier: "str",
              position: (630, 31),
             },
            ],
           },
          ),
          KeyValue(
           AttributePath {
            attributes: [
             Raw {
              content: "reqWidth",
              position: (631, 7),
             },
            ],
           },
           BinaryOperation {
            operator: Subtraction,
            operands: [
             Variable {
              identifier: "width",
              position: (631, 18),
             },
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (631, 27),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "stringLength",
                  position: (631, 31),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               Variable {
                identifier: "filler",
                position: (631, 44),
               },
              ],
             },
            ],
            position: (631, 24),
           },
          ),
         ],
         target: Assert {
          expression: FunctionApplication {
           function: PropertyAccess {
            expression: Variable {
             identifier: "lib",
             position: (633, 14),
            },
            attribute_path: AttributePath {
             attributes: [
              Raw {
               content: "assertMsg",
               position: (633, 18),
              },
             ],
            },
            default: None,
           },
           arguments: [
            BinaryOperation {
             operator: LessThanOrEqualTo,
             operands: [
              Variable {
               identifier: "strw",
               position: (633, 29),
              },
              Variable {
               identifier: "width",
               position: (633, 37),
              },
             ],
             position: (633, 34),
            },
            String {
             parts: [
              Raw {
               content: "fixedWidthString: requested string length (",
               position: (634, 10),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (635, 11),
                },
                arguments: [
                 Variable {
                  identifier: "width",
                  position: (635, 20),
                 },
                ],
               },
              },
              Raw {
               content: ") must not be shorter than actual length (",
               position: (635, 26),
              },
              Expression {
               expression: FunctionApplication {
                function: Variable {
                 identifier: "toString",
                 position: (636, 13),
                },
                arguments: [
                 Variable {
                  identifier: "strw",
                  position: (636, 22),
                 },
                ],
               },
              },
              Raw {
               content: ")",
               position: (636, 27),
              },
             ],
            },
           ],
          },
          target: IfThenElse {
           predicate: BinaryOperation {
            operator: EqualTo,
            operands: [
             Variable {
              identifier: "strw",
              position: (637, 10),
             },
             Variable {
              identifier: "width",
              position: (637, 18),
             },
            ],
            position: (637, 15),
           },
           then: Variable {
            identifier: "str",
            position: (637, 29),
           },
           else_: BinaryOperation {
            operator: Addition,
            operands: [
             Variable {
              identifier: "filler",
              position: (637, 38),
             },
             FunctionApplication {
              function: Variable {
               identifier: "fixedWidthString",
               position: (637, 47),
              },
              arguments: [
               Variable {
                identifier: "reqWidth",
                position: (637, 64),
               },
               Variable {
                identifier: "filler",
                position: (637, 73),
               },
               Variable {
                identifier: "str",
                position: (637, 80),
               },
              ],
             },
            ],
            position: (637, 45),
           },
           position: (637, 7),
          },
          position: (633, 7),
         },
         position: (629, 5),
        },
        position: (628, 37),
       },
       position: (628, 29),
      },
      position: (628, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fixedWidthNumber",
        position: (645, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "width",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: Function {
       argument: Some(
        "n",
       ),
       arguments: FunctionArguments {
        arguments: [],
        ellipsis: false,
       },
       definition: FunctionApplication {
        function: Variable {
         identifier: "fixedWidthString",
         position: (645, 32),
        },
        arguments: [
         Variable {
          identifier: "width",
          position: (645, 49),
         },
         String {
          parts: [
           Raw {
            content: "0",
            position: (645, 56),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "toString",
           position: (645, 60),
          },
          arguments: [
           Variable {
            identifier: "n",
            position: (645, 69),
           },
          ],
         },
        ],
       },
       position: (645, 29),
      },
      position: (645, 22),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "floatToString",
        position: (657, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "float",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "result",
            position: (658, 5),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "toString",
           position: (658, 14),
          },
          arguments: [
           Variable {
            identifier: "float",
            position: (658, 23),
           },
          ],
         },
        ),
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "precise",
            position: (659, 5),
           },
          ],
         },
         BinaryOperation {
          operator: EqualTo,
          operands: [
           Variable {
            identifier: "float",
            position: (659, 15),
           },
           FunctionApplication {
            function: Variable {
             identifier: "fromJSON",
             position: (659, 24),
            },
            arguments: [
             Variable {
              identifier: "result",
              position: (659, 33),
             },
            ],
           },
          ],
          position: (659, 21),
         },
        ),
       ],
       target: FunctionApplication {
        function: PropertyAccess {
         expression: Variable {
          identifier: "lib",
          position: (660, 6),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "warnIf",
            position: (660, 10),
           },
          ],
         },
         default: None,
        },
        arguments: [
         UnaryOperation {
          operator: Not,
          operand: Variable {
           identifier: "precise",
           position: (660, 19),
          },
          position: (660, 18),
         },
         String {
          parts: [
           Raw {
            content: "Imprecise conversion from float to string ",
            position: (660, 29),
           },
           Expression {
            expression: Variable {
             identifier: "result",
             position: (660, 73),
            },
           },
          ],
         },
         Variable {
          identifier: "result",
          position: (661, 5),
         },
        ],
       },
       position: (657, 26),
      },
      position: (657, 19),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isCoercibleToString",
        position: (664, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: BinaryOperation {
       operator: LogicalOr,
       operands: [
        BinaryOperation {
         operator: LogicalOr,
         operands: [
          BinaryOperation {
           operator: LogicalOr,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "elem",
              position: (665, 5),
             },
             arguments: [
              FunctionApplication {
               function: Variable {
                identifier: "typeOf",
                position: (665, 11),
               },
               arguments: [
                Variable {
                 identifier: "x",
                 position: (665, 18),
                },
               ],
              },
              List {
               elements: [
                String {
                 parts: [
                  Raw {
                   content: "path",
                   position: (665, 24),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "string",
                   position: (665, 31),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "null",
                   position: (665, 40),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "int",
                   position: (665, 47),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "float",
                   position: (665, 53),
                  },
                 ],
                },
                String {
                 parts: [
                  Raw {
                   content: "bool",
                   position: (665, 61),
                  },
                 ],
                },
               ],
               position: (665, 21),
              },
             ],
            },
            BinaryOperation {
             operator: LogicalAnd,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "isList",
                position: (666, 6),
               },
               arguments: [
                Variable {
                 identifier: "x",
                 position: (666, 13),
                },
               ],
              },
              FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (666, 18),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "all",
                   position: (666, 22),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "isCoercibleToString",
                 position: (666, 26),
                },
                Variable {
                 identifier: "x",
                 position: (666, 46),
                },
               ],
              },
             ],
             position: (666, 15),
            },
           ],
           position: (665, 69),
          },
          HasProperty {
           expression: Variable {
            identifier: "x",
            position: (667, 5),
           },
           attribute_path: AttributePath {
            attributes: [
             Raw {
              content: "outPath",
              position: (667, 9),
             },
            ],
           },
           position: (667, 7),
          },
         ],
         position: (666, 49),
        },
        HasProperty {
         expression: Variable {
          identifier: "x",
          position: (668, 5),
         },
         attribute_path: AttributePath {
          attributes: [
           Raw {
            content: "__toString",
            position: (668, 9),
           },
          ],
         },
         position: (668, 7),
        },
       ],
       position: (667, 17),
      },
      position: (664, 25),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "isStorePath",
        position: (682, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "x",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: IfThenElse {
       predicate: BinaryOperation {
        operator: LogicalAnd,
        operands: [
         UnaryOperation {
          operator: Not,
          operand: FunctionApplication {
           function: Variable {
            identifier: "isList",
            position: (683, 10),
           },
           arguments: [
            Variable {
             identifier: "x",
             position: (683, 17),
            },
           ],
          },
          position: (683, 8),
         },
         FunctionApplication {
          function: Variable {
           identifier: "isCoercibleToString",
           position: (683, 23),
          },
          arguments: [
           Variable {
            identifier: "x",
            position: (683, 43),
           },
          ],
         },
        ],
        position: (683, 20),
       },
       then: LetIn {
        bindings: [
         KeyValue(
          AttributePath {
           attributes: [
            Raw {
             content: "str",
             position: (684, 11),
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "toString",
            position: (684, 17),
           },
           arguments: [
            Variable {
             identifier: "x",
             position: (684, 26),
            },
           ],
          },
         ),
        ],
        target: BinaryOperation {
         operator: LogicalAnd,
         operands: [
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "substring",
              position: (685, 7),
             },
             arguments: [
              Int {
               value: 0,
               position: (685, 17),
              },
              Int {
               value: 1,
               position: (685, 19),
              },
              Variable {
               identifier: "str",
               position: (685, 21),
              },
             ],
            },
            String {
             parts: [
              Raw {
               content: "/",
               position: (685, 29),
              },
             ],
            },
           ],
           position: (685, 25),
          },
          BinaryOperation {
           operator: EqualTo,
           operands: [
            FunctionApplication {
             function: Variable {
              identifier: "dirOf",
              position: (686, 10),
             },
             arguments: [
              Variable {
               identifier: "str",
               position: (686, 16),
              },
             ],
            },
            Variable {
             identifier: "storeDir",
             position: (686, 23),
            },
           ],
           position: (686, 20),
          },
         ],
         position: (686, 7),
        },
        position: (684, 7),
       },
       else_: Variable {
        identifier: "false",
        position: (688, 7),
       },
       position: (683, 5),
      },
      position: (682, 17),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "toInt",
        position: (703, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "str",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: LetIn {
       bindings: [
        KeyValue(
         AttributePath {
          attributes: [
           Raw {
            content: "may_be_int",
            position: (704, 9),
           },
          ],
         },
         FunctionApplication {
          function: Variable {
           identifier: "fromJSON",
           position: (704, 22),
          },
          arguments: [
           Variable {
            identifier: "str",
            position: (704, 31),
           },
          ],
         },
        ),
       ],
       target: IfThenElse {
        predicate: FunctionApplication {
         function: Variable {
          identifier: "isInt",
          position: (705, 8),
         },
         arguments: [
          Variable {
           identifier: "may_be_int",
           position: (705, 14),
          },
         ],
        },
        then: Variable {
         identifier: "may_be_int",
         position: (706, 10),
        },
        else_: FunctionApplication {
         function: Variable {
          identifier: "throw",
          position: (707, 10),
         },
         arguments: [
          String {
           parts: [
            Raw {
             content: "Could not convert ",
             position: (707, 17),
            },
            Expression {
             expression: Variable {
              identifier: "str",
              position: (707, 37),
             },
            },
            Raw {
             content: " to int.",
             position: (707, 41),
            },
           ],
          },
         ],
        },
        position: (705, 5),
       },
       position: (704, 5),
      },
      position: (703, 11),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "readPathsFromFile",
        position: (724, 3),
       },
      ],
     },
     FunctionApplication {
      function: PropertyAccess {
       expression: Variable {
        identifier: "lib",
        position: (724, 23),
       },
       attribute_path: AttributePath {
        attributes: [
         Raw {
          content: "warn",
          position: (724, 27),
         },
        ],
       },
       default: None,
      },
      arguments: [
       String {
        parts: [
         Raw {
          content: "lib.readPathsFromFile is deprecated, use a list instead",
          position: (724, 33),
         },
        ],
       },
       Function {
        argument: Some(
         "rootPath",
        ),
        arguments: FunctionArguments {
         arguments: [],
         ellipsis: false,
        },
        definition: Function {
         argument: Some(
          "file",
         ),
         arguments: FunctionArguments {
          arguments: [],
          ellipsis: false,
         },
         definition: LetIn {
          bindings: [
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "lines",
               position: (727, 9),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (727, 17),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "splitString",
                 position: (727, 21),
                },
               ],
              },
              default: None,
             },
             arguments: [
              String {
               parts: [
                Raw {
                 content: "\n",
                 position: (727, 34),
                },
               ],
              },
              FunctionApplication {
               function: Variable {
                identifier: "readFile",
                position: (727, 39),
               },
               arguments: [
                Variable {
                 identifier: "file",
                 position: (727, 48),
                },
               ],
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "removeComments",
               position: (728, 9),
              },
             ],
            },
            FunctionApplication {
             function: PropertyAccess {
              expression: Variable {
               identifier: "lib",
               position: (728, 26),
              },
              attribute_path: AttributePath {
               attributes: [
                Raw {
                 content: "filter",
                 position: (728, 30),
                },
               ],
              },
              default: None,
             },
             arguments: [
              Function {
               argument: Some(
                "line",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: LogicalAnd,
                operands: [
                 BinaryOperation {
                  operator: NotEqualTo,
                  operands: [
                   Variable {
                    identifier: "line",
                    position: (728, 44),
                   },
                   String {
                    parts: [],
                   },
                  ],
                  position: (728, 49),
                 },
                 UnaryOperation {
                  operator: Not,
                  operand: FunctionApplication {
                   function: PropertyAccess {
                    expression: Variable {
                     identifier: "lib",
                     position: (728, 60),
                    },
                    attribute_path: AttributePath {
                     attributes: [
                      Raw {
                       content: "hasPrefix",
                       position: (728, 64),
                      },
                     ],
                    },
                    default: None,
                   },
                   arguments: [
                    String {
                     parts: [
                      Raw {
                       content: "#",
                       position: (728, 75),
                      },
                     ],
                    },
                    Variable {
                     identifier: "line",
                     position: (728, 78),
                    },
                   ],
                  },
                  position: (728, 58),
                 },
                ],
                position: (728, 55),
               },
               position: (728, 38),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "relativePaths",
               position: (729, 9),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "removeComments",
              position: (729, 25),
             },
             arguments: [
              Variable {
               identifier: "lines",
               position: (729, 40),
              },
             ],
            },
           ),
           KeyValue(
            AttributePath {
             attributes: [
              Raw {
               content: "absolutePaths",
               position: (730, 9),
              },
             ],
            },
            FunctionApplication {
             function: Variable {
              identifier: "map",
              position: (730, 25),
             },
             arguments: [
              Function {
               argument: Some(
                "path",
               ),
               arguments: FunctionArguments {
                arguments: [],
                ellipsis: false,
               },
               definition: BinaryOperation {
                operator: Addition,
                operands: [
                 Variable {
                  identifier: "rootPath",
                  position: (730, 36),
                 },
                 String {
                  parts: [
                   Raw {
                    content: "/",
                    position: (730, 48),
                   },
                   Expression {
                    expression: Variable {
                     identifier: "path",
                     position: (730, 51),
                    },
                   },
                  ],
                 },
                ],
                position: (730, 45),
               },
               position: (730, 30),
              },
              Variable {
               identifier: "relativePaths",
               position: (730, 59),
              },
             ],
            },
           ),
          ],
          target: Variable {
           identifier: "absolutePaths",
           position: (732, 9),
          },
          position: (726, 7),
         },
         position: (725, 16),
        },
        position: (725, 6),
       },
      ],
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "fileContents",
        position: (744, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "file",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: Variable {
        identifier: "removeSuffix",
        position: (744, 24),
       },
       arguments: [
        String {
         parts: [
          Raw {
           content: "\n",
           position: (744, 38),
          },
         ],
        },
        FunctionApplication {
         function: Variable {
          identifier: "readFile",
          position: (744, 43),
         },
         arguments: [
          Variable {
           identifier: "file",
           position: (744, 52),
          },
         ],
        },
       ],
      },
      position: (744, 18),
     },
    ),
    KeyValue(
     AttributePath {
      attributes: [
       Raw {
        content: "sanitizeDerivationName",
        position: (759, 3),
       },
      ],
     },
     Function {
      argument: Some(
       "string",
      ),
      arguments: FunctionArguments {
       arguments: [],
       ellipsis: false,
      },
      definition: FunctionApplication {
       function: PropertyAccess {
        expression: Variable {
         identifier: "lib",
         position: (759, 36),
        },
        attribute_path: AttributePath {
         attributes: [
          Raw {
           content: "pipe",
           position: (759, 40),
          },
         ],
        },
        default: None,
       },
       arguments: [
        Variable {
         identifier: "string",
         position: (759, 45),
        },
        List {
         elements: [
          Variable {
           identifier: "unsafeDiscardStringContext",
           position: (762, 5),
          },
          Function {
           argument: Some(
            "x",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "elemAt",
             position: (764, 9),
            },
            arguments: [
             FunctionApplication {
              function: Variable {
               identifier: "match",
               position: (764, 17),
              },
              arguments: [
               String {
                parts: [
                 Raw {
                  content: "\\.*(.*)",
                  position: (764, 24),
                 },
                ],
               },
               Variable {
                identifier: "x",
                position: (764, 34),
               },
              ],
             },
             Int {
              value: 0,
              position: (764, 37),
             },
            ],
           },
           position: (764, 6),
          },
          FunctionApplication {
           function: Variable {
            identifier: "split",
            position: (768, 6),
           },
           arguments: [
            String {
             parts: [
              Raw {
               content: "[^[:alnum:]+._?=-]+",
               position: (768, 13),
              },
             ],
            },
           ],
          },
          FunctionApplication {
           function: Variable {
            identifier: "concatMapStrings",
            position: (770, 6),
           },
           arguments: [
            Function {
             argument: Some(
              "s",
             ),
             arguments: FunctionArguments {
              arguments: [],
              ellipsis: false,
             },
             definition: IfThenElse {
              predicate: FunctionApplication {
               function: PropertyAccess {
                expression: Variable {
                 identifier: "lib",
                 position: (770, 30),
                },
                attribute_path: AttributePath {
                 attributes: [
                  Raw {
                   content: "isList",
                   position: (770, 34),
                  },
                 ],
                },
                default: None,
               },
               arguments: [
                Variable {
                 identifier: "s",
                 position: (770, 41),
                },
               ],
              },
              then: String {
               parts: [
                Raw {
                 content: "-",
                 position: (770, 49),
                },
               ],
              },
              else_: Variable {
               identifier: "s",
               position: (770, 57),
              },
              position: (770, 27),
             },
             position: (770, 24),
            },
           ],
          },
          Function {
           argument: Some(
            "x",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: FunctionApplication {
            function: Variable {
             identifier: "substring",
             position: (772, 9),
            },
            arguments: [
             FunctionApplication {
              function: PropertyAccess {
               expression: Variable {
                identifier: "lib",
                position: (772, 20),
               },
               attribute_path: AttributePath {
                attributes: [
                 Raw {
                  content: "max",
                  position: (772, 24),
                 },
                ],
               },
               default: None,
              },
              arguments: [
               BinaryOperation {
                operator: Subtraction,
                operands: [
                 FunctionApplication {
                  function: Variable {
                   identifier: "stringLength",
                   position: (772, 29),
                  },
                  arguments: [
                   Variable {
                    identifier: "x",
                    position: (772, 42),
                   },
                  ],
                 },
                 Int {
                  value: 207,
                  position: (772, 46),
                 },
                ],
                position: (772, 44),
               },
               Int {
                value: 0,
                position: (772, 51),
               },
              ],
             },
             UnaryOperation {
              operator: Negate,
              operand: Int {
               value: 1,
               position: (772, 56),
              },
              position: (772, 55),
             },
             Variable {
              identifier: "x",
              position: (772, 59),
             },
            ],
           },
           position: (772, 6),
          },
          Function {
           argument: Some(
            "x",
           ),
           arguments: FunctionArguments {
            arguments: [],
            ellipsis: false,
           },
           definition: IfThenElse {
            predicate: BinaryOperation {
             operator: EqualTo,
             operands: [
              FunctionApplication {
               function: Variable {
                identifier: "stringLength",
                position: (774, 12),
               },
               arguments: [
                Variable {
                 identifier: "x",
                 position: (774, 25),
                },
               ],
              },
              Int {
               value: 0,
               position: (774, 30),
              },
             ],
             position: (774, 27),
            },
            then: String {
             parts: [
              Raw {
               content: "unknown",
               position: (774, 38),
              },
             ],
            },
            else_: Variable {
             identifier: "x",
             position: (774, 52),
            },
            position: (774, 9),
           },
           position: (774, 6),
          },
         ],
         position: (759, 52),
        },
       ],
      },
      position: (759, 28),
     },
    ),
   ],
   recursive: true,
   position: (9, 1),
  },
  position: (3, 1),
 },
 position: (2, 1),
}